Codex App 强开 Fast、插件和 Goal 记录

1
#!/usr/bin/env bash
2
set -euo pipefail
3

4
APP_PATH="${1:-/Applications/Codex.app}"
5
KEEP_WORKDIR="${KEEP_WORKDIR:-0}"
6

7
WORKDIR="$(mktemp -d "${TMPDIR:-/tmp}/codex-fast-repatch.XXXXXX")"
8
EXTRACT_DIR="$WORKDIR/extracted"
9
NEW_ASAR="$WORKDIR/app.asar"
10
ASAR_PATH="$APP_PATH/Contents/Resources/app.asar"
11
INFO_PLIST="$APP_PATH/Contents/Info.plist"
12

13
log() {
14
  printf '[codex-local-patch] %s\n' "$*"
15
}
16

17
fail() {
18
  printf '[codex-local-patch] error: %s\n' "$*" >&2
19
  exit 1
20
}
21

22
cleanup() {
23
  if [[ "$KEEP_WORKDIR" == "1" ]]; then
24
    log "keeping workdir: $WORKDIR"
25
    return
26
  fi
27
  rm -rf "$WORKDIR"
28
}
29

30
trap cleanup EXIT
31

32
require_cmd() {
33
  command -v "$1" >/dev/null 2>&1 || fail "missing command: $1"
34
}
35

36
require_cmd node
37
require_cmd npx
38
require_cmd rg
39
require_cmd codesign
40
require_cmd plutil
41
require_cmd /usr/libexec/PlistBuddy
42

43
[[ -d "$APP_PATH" ]] || fail "app not found: $APP_PATH"
44
[[ -f "$ASAR_PATH" ]] || fail "asar not found: $ASAR_PATH"
45
[[ -f "$INFO_PLIST" ]] || fail "Info.plist not found: $INFO_PLIST"
46

47
VERSION="$(defaults read "$APP_PATH/Contents/Info" CFBundleShortVersionString 2>/dev/null || true)"
48
BUILD="$(defaults read "$APP_PATH/Contents/Info" CFBundleVersion 2>/dev/null || true)"
49

50
log "target app: $APP_PATH"
51
log "version/build: ${VERSION:-unknown} / ${BUILD:-unknown}"
52

53
if pgrep -x "Codex" >/dev/null 2>&1; then
54
  log "quitting running Codex process"
55
  osascript -e 'tell application "Codex" to quit' >/dev/null 2>&1 || true
56
  sleep 2
57
  pkill -x "Codex" >/dev/null 2>&1 || true
58
fi
59

60
log "extracting app.asar"
61
npx --yes asar extract "$ASAR_PATH" "$EXTRACT_DIR" >/dev/null
62

63
PATCH_TARGET="$(rg -l 'featureRequirements\?\.fast_mode' "$EXTRACT_DIR/webview/assets" | head -n 1 || true)"
64
[[ -n "$PATCH_TARGET" ]] || fail "could not find fast-mode gate in extracted assets"
65

66
PLUGIN_SIDEBAR_TARGET="$(rg -l '533078438' "$EXTRACT_DIR/webview/assets" | head -n 1 || true)"
67
[[ -n "$PLUGIN_SIDEBAR_TARGET" ]] || fail "could not find plugin sidebar gate in extracted assets"
68

69
PLUGIN_SKILLS_TARGET="$(rg -l 'pluginDeepLinkAuthBlocked===!0' "$EXTRACT_DIR/webview/assets" | head -n 1 || true)"
70
[[ -n "$PLUGIN_SKILLS_TARGET" ]] || fail "could not find plugin skills-page auth gate in extracted assets"
71

72
PLUGIN_DETAIL_TARGET="$(rg -l 'pluginDeepLinkAuthBlocked:!0' "$EXTRACT_DIR/webview/assets" | head -n 1 || true)"
73
[[ -n "$PLUGIN_DETAIL_TARGET" ]] || fail "could not find plugin detail auth gate in extracted assets"
74

75
GOAL_TARGET="$(
76
  rg -l 'set-thread-goal-status|3074100722.*`goals`' "$EXTRACT_DIR/webview/assets" | while IFS= read -r file; do
77
    if rg -q 'threadGoalObjective|3074100722.*`goals`' "$file"; then
78
      printf '%s\n' "$file"
79
    fi
80
  done | head -n 1 || true
81
)"
82
[[ -n "$GOAL_TARGET" ]] || fail "could not find goal slash-command gate in extracted assets"
83

84
log "fast-mode patch target: ${PATCH_TARGET#$EXTRACT_DIR/}"
85
log "plugin sidebar patch target: ${PLUGIN_SIDEBAR_TARGET#$EXTRACT_DIR/}"
86
log "plugin skills-page patch target: ${PLUGIN_SKILLS_TARGET#$EXTRACT_DIR/}"
87
log "plugin detail patch target: ${PLUGIN_DETAIL_TARGET#$EXTRACT_DIR/}"
88
log "goal patch target: ${GOAL_TARGET#$EXTRACT_DIR/}"
89

90
PATCH_RESULT="$(
91
  node - "$PATCH_TARGET" <<'NODE'
92
const fs = require('node:fs');
93

94
const file = process.argv[2];
95
const text = fs.readFileSync(file, 'utf8');
96

97
const legacyPatchedRe =
98
  /function L\(e\)\{let (\w+)=v\(x\),(\w+)=e\?\.hostId\?\?\1,\{data:(\w+)\}=d\(E,\2\);return \3\?\.requirements\?\.featureRequirements\?\.fast_mode!==!1\}/;
99

100
const currentDirectPatchedRe =
101
  /featureRequirements\?\.fast_mode===!1;return!\w+\}/;
102

103
const legacyOriginalRe =
104
  /function L\(e\)\{let (\w+)=v\(x\),(\w+)=e\?\.hostId\?\?\1,(\w+)=O\(\2\),\{data:(\w+)\}=d\(E,\2\);return!\(\3\?\.authMethod!==`chatgpt`\|\|\4\?\.requirements\?\.featureRequirements\?\.fast_mode===!1\)\}/;
105

106
const currentDirectOriginalRe =
107
  /function (\w+)\(e\)\{let (\w+)=([^,;]+),(\w+)=e\?\.hostId\?\?\2,(\w+)=(\w+\(\4\)),\{data:(\w+)\}=(\w+\(\w+,\4\)),(\w+)=\7\?\.requirements\?\.featureRequirements\?\.fast_mode===!1;return!\(\5\?\.authMethod!==`chatgpt`\|\|\9\)\}/;
108

109
const currentSplitConditionRe =
110
  /if\((\w+)\?\.authMethod!==`chatgpt`\|\|(\w+)\)\{/;
111

112
if (
113
  legacyPatchedRe.test(text) ||
114
  (currentDirectPatchedRe.test(text) &&
115
    !legacyOriginalRe.test(text) &&
116
    !currentDirectOriginalRe.test(text) &&
117
    !currentSplitConditionRe.test(text))
118
) {
119
  process.stdout.write('already-patched');
120
  process.exit(0);
121
}
122

123
let next = text;
124
let patched = !1;
125

126
const legacyMatch = next.match(legacyOriginalRe);
127
if (legacyMatch) {
128
  const [, rootVar, hostVar, , dataVar] = legacyMatch;
129
  const replacement =
130
    `function L(e){let ${rootVar}=v(x),${hostVar}=e?.hostId??${rootVar},{data:${dataVar}}=d(E,${hostVar});return ${dataVar}?.requirements?.featureRequirements?.fast_mode!==!1}`;
131
  next = next.replace(legacyOriginalRe, replacement);
132
  patched = !0;
133
}
134

135
if (!patched) {
136
  const currentMatch = next.match(currentDirectOriginalRe);
137
  if (currentMatch) {
138
    const [, fn, rootVar, rootExpr, hostVar, , , dataVar, dataCall, disabledVar] = currentMatch;
139
    const replacement =
140
      `function ${fn}(e){let ${rootVar}=${rootExpr},${hostVar}=e?.hostId??${rootVar},{data:${dataVar}}=${dataCall},${disabledVar}=${dataVar}?.requirements?.featureRequirements?.fast_mode===!1;return!${disabledVar}}`;
141
    next = next.replace(currentDirectOriginalRe, replacement);
142
    patched = !0;
143
  }
144

145
  if (/canUseFastMode:!1/.test(next)) {
146
    const splitNext = next.replace(currentSplitConditionRe, 'if($2){');
147
    if (splitNext === next) {
148
      process.stderr.write('split-gate-target-not-found\n');
149
      process.exit(2);
150
    }
151
    next = splitNext;
152
    patched = !0;
153
  }
154
}
155

156
if (!patched) {
157
  process.stderr.write('patch-target-not-found\n');
158
  process.exit(2);
159
}
160

161
if (next === text) {
162
  process.stderr.write('patch-did-not-change-file\n');
163
  process.exit(3);
164
}
165

166
fs.writeFileSync(file, next);
167
process.stdout.write('patched');
168
NODE
169
)" || fail "failed to patch fast-mode gate"
170

171
log "patch result: $PATCH_RESULT"
172

173
PLUGIN_PATCH_RESULT="$(
174
  node - "$PLUGIN_SIDEBAR_TARGET" "$PLUGIN_SKILLS_TARGET" "$PLUGIN_DETAIL_TARGET" <<'NODE'
175
const fs = require('node:fs');
176

177
const [sidebarFile, skillsFile, detailFile] = process.argv.slice(2);
178
let changed = false;
179

180
function rewriteFile(label, file, patchedRe, originalRe, replacement) {
181
  const text = fs.readFileSync(file, 'utf8');
182

183
  if (patchedRe.test(text)) {
184
    return;
185
  }
186

187
  const next = text.replace(originalRe, replacement);
188
  if (next === text) {
189
    process.stderr.write(`${label}-target-not-found\n`);
190
    process.exit(2);
191
  }
192

193
  fs.writeFileSync(file, next);
194
  changed = true;
195
}
196

197
rewriteFile(
198
  'plugin-sidebar-gate',
199
  sidebarFile,
200
  /\{authMethod:(\w+)\}=([A-Za-z_$][\w$]*)\(\),(\w+)=([A-Za-z_$][\w$]*)\(`533078438`\),(\w+)=!1,(\w+)=e&&\3&&\5,(\w+)=([A-Za-z_$][\w$]*)\(\{hostId:([A-Za-z_$][\w$]*)\}\),(\w+)=e&&\7&&!\5,/,
201
  /\{authMethod:(\w+)\}=([A-Za-z_$][\w$]*)\(\),(\w+)=([A-Za-z_$][\w$]*)\(`533078438`\),(\w+)=([A-Za-z_$][\w$]*)\(\1\),(\w+)=e&&\3&&\5,(\w+)=([A-Za-z_$][\w$]*)\(\{hostId:([A-Za-z_$][\w$]*)\}\),(\w+)=e&&\8&&!\5,/,
202
  (_match, authMethodVar, authHook, flagVar, featureFlagHook, apiKeyGateVar, _apiKeyGateHook, disabledVar, availabilityVar, availabilityHook, hostIdVar, enabledVar) =>
203
    `{authMethod:${authMethodVar}}=${authHook}(),${flagVar}=${featureFlagHook}(\`533078438\`),${apiKeyGateVar}=!1,${disabledVar}=e&&${flagVar}&&${apiKeyGateVar},${availabilityVar}=${availabilityHook}({hostId:${hostIdVar}}),${enabledVar}=e&&${availabilityVar}&&!${apiKeyGateVar},`
204
);
205

206
rewriteFile(
207
  'plugin-skills-page-gate',
208
  skillsFile,
209
  /let (\w+)=!1,(\w+),(\w+);if\(e\[(\d+)\]!==(\w+)\|\|e\[(\d+)\]!==\1\|\|e\[(\d+)\]!==(\w+)\?/,
210
  /let (\w+)=(\w+),(\w+),(\w+);if\(e\[(\d+)\]!==(\w+)\|\|e\[(\d+)\]!==\1\|\|e\[(\d+)\]!==(\w+)\?/,
211
  (_match, pluginAuthBlockedVar, _sourceVar, effectFnVar, effectDepsVar, slotA, deepLinkBlockedVar, slotB, slotC, toastApiVar) =>
212
    `let ${pluginAuthBlockedVar}=!1,${effectFnVar},${effectDepsVar};if(e[${slotA}]!==${deepLinkBlockedVar}||e[${slotB}]!==${pluginAuthBlockedVar}||e[${slotC}]!==${toastApiVar}?`
213
);
214

215
rewriteFile(
216
  'plugin-detail-gate',
217
  detailFile,
218
  /\{authMethod:(\w+)\}=([A-Za-z_$][\w$]*)\(\);if\(!1\)\{let (\w+);return/,
219
  /\{authMethod:(\w+)\}=([A-Za-z_$][\w$]*)\(\);if\(([A-Za-z_$][\w$]*)\(\1\)\)\{let (\w+);return/,
220
  (_match, authMethodVar, authHook, _isAuthBlockedHook, redirectElementVar) =>
221
    `{authMethod:${authMethodVar}}=${authHook}();if(!1){let ${redirectElementVar};return`
222
);
223

224
process.stdout.write(changed ? 'patched' : 'already-patched');
225
NODE
226
)" || fail "failed to patch plugin auth gates"
227

228
log "plugin patch result: $PLUGIN_PATCH_RESULT"
229

230
GOAL_PATCH_RESULT="$(
231
  node - "$GOAL_TARGET" <<'NODE'
232
const fs = require('node:fs');
233

234
const file = process.argv[2];
235
const text = fs.readFileSync(file, 'utf8');
236

237
const goalPatchedRe = /(\w+)=([A-Za-z_$][\w$]*)!==`cloud`,(\w+)=([^,]+),/;
238
const goalOriginalRe =
239
  /(\w+)=([A-Za-z_$][\w$]*)\(`3074100722`\)&&([A-Za-z_$][\w$]*)\((\w+)\?\.config,`goals`\)===!0&&(\w+)!==`cloud`,(\w+)=([^,]+),/;
240

241
const slashOriginal =
242
  'function Nx(e,t){let n=t.trim();if(n.length===0)return e;let r=new Map;return e.forEach(e=>{let t=e.group??null;r.has(t)||r.set(t,r.size)}),(0,Tx.default)(e.map(e=>({command:e,score:zi(e.title,n)})).filter(e=>e.score>0),[e=>r.get(e.command.group??null)??2**53-1,e=>-e.score,e=>e.command.title]).map(e=>e.command)}';
243

244
const slashPatched =
245
  'function Nx(e,t){let n=t.trim().replace(/^\\/+/,"");if(n.length===0)return e;let r=new Map;return e.forEach(e=>{let t=e.group??null;r.has(t)||r.set(t,r.size)}),(0,Tx.default)(e.map(e=>({command:e,score:Math.max(zi(e.title,n),zi(e.id,n))})).filter(e=>e.score>0),[e=>r.get(e.command.group??null)??2**53-1,e=>-e.score,e=>e.command.title]).map(e=>e.command)}';
246

247
let next = text;
248
let changed = false;
249

250
if (!next.includes(slashPatched)) {
251
  if (!next.includes(slashOriginal)) {
252
    process.stderr.write('slash-match-patch-target-not-found\n');
253
    process.exit(2);
254
  }
255
  next = next.replace(slashOriginal, slashPatched);
256
  changed = true;
257
}
258

259
if (goalOriginalRe.test(next)) {
260
  next = next.replace(
261
    goalOriginalRe,
262
    (_match, goalGateVar, _statsigFn, _configAccessFn, _configVar, modeVar, hasGoalVar, hasGoalExpr) =>
263
      `${goalGateVar}=${modeVar}!==\`cloud\`,${hasGoalVar}=${hasGoalExpr},`,
264
  );
265
  changed = true;
266
} else if (!goalPatchedRe.test(next)) {
267
  process.stderr.write('goal-patch-target-not-found\n');
268
  process.exit(2);
269
}
270

271
if (!changed) {
272
  process.stdout.write('already-patched');
273
  process.exit(0);
274
}
275

276
fs.writeFileSync(file, next);
277
process.stdout.write('patched');
278
NODE
279
)" || fail "failed to patch goal slash-command gate"
280

281
log "goal patch result: $GOAL_PATCH_RESULT"
282

283
if [[ "$PATCH_RESULT" == "already-patched" && "$PLUGIN_PATCH_RESULT" == "already-patched" && "$GOAL_PATCH_RESULT" == "already-patched" ]]; then
284
  log "fast-mode, plugin, and goal gates are already patched for this build"
285
  exit 0
286
fi
287

288
log "repacking app.asar"
289
npx --yes asar pack "$EXTRACT_DIR" "$NEW_ASAR" >/dev/null
290

291
ASAR_HEADER_HASH="$(
292
  node - "$NEW_ASAR" <<'NODE'
293
const fs = require('node:fs');
294
const crypto = require('node:crypto');
295

296
const file = process.argv[2];
297
const fd = fs.openSync(file, 'r');
298

299
try {
300
  const sizeBuf = Buffer.alloc(8);
301
  const sizeRead = fs.readSync(fd, sizeBuf, 0, 8, 0);
302
  if (sizeRead !== 8) {
303
    throw new Error('could not read asar size pickle');
304
  }
305

306
  const headerSize = sizeBuf.readUInt32LE(4);
307
  const headerBuf = Buffer.alloc(headerSize);
308
  const headerRead = fs.readSync(fd, headerBuf, 0, headerSize, 8);
309
  if (headerRead !== headerSize) {
310
    throw new Error('could not read asar header');
311
  }
312

313
  const stringLength = headerBuf.readUInt32LE(4);
314
  const headerStringBytes = headerBuf.subarray(8, 8 + stringLength);
315
  const hash = crypto.createHash('sha256').update(headerStringBytes).digest('hex');
316
  process.stdout.write(hash);
317
} finally {
318
  fs.closeSync(fd);
319
}
320
NODE
321
)" || fail "failed to compute Electron asar integrity hash"
322

323
log "new ElectronAsarIntegrity hash: $ASAR_HEADER_HASH"
324

325
cp "$NEW_ASAR" "$ASAR_PATH"
326
/usr/libexec/PlistBuddy -c "Set :ElectronAsarIntegrity:Resources/app.asar:hash $ASAR_HEADER_HASH" "$INFO_PLIST"
327

328
log "re-signing app bundle"
329
codesign --force --deep --sign - "$APP_PATH" >/dev/null
330

331
FINAL_HASH="$(/usr/libexec/PlistBuddy -c 'Print :ElectronAsarIntegrity:Resources/app.asar:hash' "$INFO_PLIST")"
332
[[ "$FINAL_HASH" == "$ASAR_HEADER_HASH" ]] || fail "plist hash verification failed"
333

334
log "done"