codex-copilot-dx 0.6.11 → 0.6.12

package/README.md

@@ -118,11 +118,15 @@ discovery tries the compatible local CCDX merge first, and only exact enabled
 Anthropic model IDs use the isolated CCDX Claude profile. Neither credential is
 copied into the other application.
 
-The current patch recipes support only the exact, unmodified PM Studio 2.9.7
-and 2.9.10 bundles on macOS. This is exact-version support, not a version range:
-2.9.11 and other unknown builds remain unsupported until they receive their own
-verified recipe. Authorize the isolated Claude profile first, quit PM Studio
-and its updater, then run the one-time setup command:
+CCDX keeps exact built-in recipes for PM Studio 2.9.7 and 2.9.10, and can also
+derive a source-bound recipe for a newer macOS build when its signed App layout,
+ASAR integrity metadata, and one exact Copilot configuration module remain
+structurally compatible. This is best-effort semantic compatibility, not a
+promise that every future PM Studio architecture can be patched. A missing or
+ambiguous module, changed request transport, unsupported integrity policy, or
+unverifiable source is rejected without modifying the App. Authorize the
+isolated Claude profile first, quit PM Studio and its updater, then run the
+one-time setup command:
 
 ```bash
 ccdx auth login claude --reauth --github-login <personal-github-login>
@@ -138,24 +142,30 @@ ccdx pms status
 
 `ccdx pm-studio status` and `ccdx pm-studio setup` are equivalent long-form aliases.
 
-`ccdx pms setup` performs only local preflight, backup, staging, integrity,
-signing, and replacement work. It never starts Device Flow, the adapter,
-Codex, or PM Studio, and it does not modify PM profiles, cached model lists, or
-saved PM tokens. Unknown versions, hashes, signatures, partial patches, a
-running PM process, insufficient space, and every pre-replacement verification
-failure leave the installed App unchanged. If the final read-only verification
-after an atomic replacement detects an exceptional filesystem drift, setup
-does not attempt a second automatic write: it preserves the verified backup,
-retains any diagnostic stage still present, and prints recovery paths. Repeating
-setup for the exact installed recipe is idempotent.
-
-The official 2.9.10 artifact can fail macOS's vendor-signature verifier even
-though its signing metadata remains readable. CCDX does not generally ignore
-that failure: the 2.9.10 exception is accepted only when the complete App tree,
-including every file, mode, symlink, and non-volatile extended attribute,
-matches the frozen official fingerprint. The staged and installed CCDX patch
-must still pass strict ad-hoc signature verification and match the complete
-patched-tree record in the backup manifest.
+`ccdx pms setup` performs preflight, source verification, backup, staging,
+integrity, signing, and replacement work. It never starts Device Flow, the
+adapter, Codex, or PM Studio, and it does not modify PM profiles, cached model
+lists, or saved PM tokens. A structurally compatible unknown version with an
+intact vendor signature is verified locally. If the upstream release has the
+known invalid-signature shape, setup downloads only the exact stable asset from
+the fixed official GitHub repository, enforces its API-provided SHA-256 and
+size, extracts it privately, and requires the installed App to match that tree
+(apart from strictly scoped locale pruning) before any backup or staging write.
+Network, hash, tree, structure, partial-patch, running-process, space, and every
+other pre-replacement failure leave the installed App unchanged. If final
+read-only verification after an atomic replacement detects exceptional
+filesystem drift, setup does not attempt a second automatic write: it preserves
+the verified backup, retains any diagnostic stage still present, and prints
+recovery paths. Repeating setup reuses the version/source-bound verified backup
+and is idempotent; status and repeated setup do not redownload the release.
+
+Some official PM Studio artifacts can fail macOS's vendor-signature verifier
+even though their signing metadata remains readable. CCDX does not generally
+ignore that failure: exact built-in recipes require their frozen official
+fingerprint, while compatible unknown versions require the verified official
+GitHub asset and tree comparison described above. The staged and installed
+CCDX patch must still pass strict ad-hoc signature verification and match the
+complete patched-tree record in the backup manifest.
 
 The patch uses split origins, not an App-wide proxy. GPT and other non-Claude
 inference requests remain on PM Studio's native official GitHub Copilot origin;
@@ -181,8 +191,7 @@ backup over a different PM Studio version or build.
 
 To restore, first quit PM Studio and its updater. Use the exact verified backup
 path printed by setup as `BACKUP_APP`, then confirm that both the installed App
-and backup still report the same version/build printed by setup (`2.9.7/2.9.7`
-or `2.9.10/2.9.10`):
+and backup still report the same version/build printed by setup:
 
 ```bash
 BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
@@ -192,8 +201,9 @@ BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
 /usr/bin/plutil -extract CFBundleVersion raw -o - "$BACKUP_APP/Contents/Info.plist"
 ```
 
-Only when all four values match the one exact recipe, move the patched App
-aside, restore the complete vendor bundle, and verify it before launch:
+Only when all four values match each other and the version/build recorded in the
+source-bound manifest, move the patched App aside, restore the complete vendor
+bundle, and verify it before launch:
 
 ```bash
 RECOVERY_DIR="$(/usr/bin/mktemp -d '/Applications/CCDX-PM-Studio-recovery.XXXXXX')"
@@ -204,10 +214,10 @@ mv "/Applications/PM Studio.app" "$PATCHED_APP"
 ccdx pms status
 ```
 
-For 2.9.10, the vendor `codesign` command may report the documented upstream
-signature failure; in that case the App-patch row from `ccdx pms status` must
-still classify the restored bundle as exact supported clean content rather than
-integrity drift. If the version check, copy, or both verification paths fail,
+For an official artifact with the documented upstream signature failure, the
+App-patch row from `ccdx pms status` must still classify the restored bundle as
+verified clean content rather than integrity drift. If the version check, copy,
+or both verification paths fail,
 do not launch the restored App. Keep the moved patched bundle at `$PATCHED_APP`
 and reinstall the official PM Studio instead of applying a version-mismatched
 backup. CCDX never runs these restore commands or `sudo` automatically.
@@ -280,8 +290,9 @@ The command exits with status `1` when it finds an invalid configuration and `0`
 The doctor checks the GitHub token, Codex config, Claude Code settings, Claude
 App gateway profile, adapter availability, and an installed PM Studio bundle.
 It ends with passed/warning/error totals and deduplicated next-step commands.
-An absent PM Studio installation is ignored; unsupported versions are reported
-without modification, while integrity drift remains an error.
+An absent PM Studio installation is ignored; versions whose compatibility
+cannot be safely verified are reported without modification, while integrity
+drift remains an error.
 
 For a read-only live check of the saved GitHub token, Copilot entitlement, and models endpoint, run:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/cli-options.mjs

@@ -292,8 +292,8 @@ function topicHelp(name, topic) {
     doctor: `Usage:\n  ${name} doctor [--online] [--compat] [--profile codex|claude|all]\n\nChecks local credentials, client configuration, PM Studio state, and the adapter. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage.`,
     status: `Usage:\n  ${name} status\n\nShows bounded runtime, routing, performance, cache, queue, and PM relay metrics from a running adapter.`,
     models: `Usage:\n  ${name} models [--profile codex|claude] [--format table|plain]\n\nPerforms a fresh, read-only Copilot model-directory lookup for one saved profile. Interactive terminals use a table by default.`,
-    pms: `Usage:\n  ${name} pms status [--format table|plain]\n  ${name} pms setup\n  ${name} pm-studio status [--format table|plain]\n  ${name} pm-studio setup\n\nInspects or installs the version-locked PM Studio loopback patch. setup modifies the installed app only after all preflight checks pass.`,
-    "pms setup": `Usage:\n  ${name} pms setup\n\nBacks up, patches, verifies, and ad-hoc signs an exactly supported PM Studio bundle. Unknown versions and drift are never modified.`,
+    pms: `Usage:\n  ${name} pms status [--format table|plain]\n  ${name} pms setup\n  ${name} pm-studio status [--format table|plain]\n  ${name} pm-studio setup\n\nInspects or installs the fail-closed PM Studio split-origin patch. setup modifies the installed app only after exact or semantic compatibility and source checks pass.`,
+    "pms setup": `Usage:\n  ${name} pms setup\n\nBacks up, patches, verifies, and ad-hoc signs an exact or structurally compatible PM Studio bundle. Unverifiable versions and drift are never modified.`,
     "pms status": `Usage:\n  ${name} pms status [--format table|plain]\n\nRead-only inspection of the installed PM Studio version, patch integrity, Claude profile, and relay availability. Interactive terminals use a table by default.`,
     usage: `Usage:\n  ${name} usage [--format table|plain]\n\nSummarizes local token usage metadata without reading prompt or completion content. Interactive terminals use a table by default.`,
     "auto-review-model": `Usage:\n  ${name} auto-review-model\n\nInteractively selects an enabled Responses model for Codex Auto-review.`,

package/src/doctor.mjs

@@ -603,7 +603,7 @@ export async function collectDoctorChecks({
         fix: "ccdx pms setup",
       });
     } else if (pm.app.state === "unsupported") {
-      checks.push({ kind: "warn", message: `PM Studio ${version} has no exact patch recipe; no files will be changed` });
+      checks.push({ kind: "warn", message: `PM Studio ${version} compatibility cannot be safely verified; no files will be changed` });
     } else if (pm.app.state === "drift" || pm.app.state === "error") {
       checks.push({ kind: "err", message: `PM Studio integrity check failed: ${pm.app.issues.join("; ")}` });
     }

package/src/pm-studio-asar.mjs

@@ -7,6 +7,11 @@ export const ELECTRON_ASAR_INTEGRITY_SENTINEL = "AGbevlPCksUGKNL8TSn7wGmJEuJsXb2
 
 const PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH = 2_121;
 const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256 = "3da6245d676015ab6cd26e4d6a0d2f54894a687c370aa419c5ad170533d086aa";
+const PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR = "47024(I,e,t){";
+const PM_STUDIO_COPILOT_CONFIG_MODULE_PATH = "dist/main/main.js";
+const PM_STUDIO_COMPATIBILITY_ID = "exact-copilot-config-module-v1";
+const PM_STUDIO_COMPATIBLE_TARGET_MAX_BYTES = 128 * 1024 * 1024;
+const PM_STUDIO_COMPATIBLE_BLOCK_MAX_COUNT = 16_384;
 
 function splitOriginConfigModule() {
   const source = `47024(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"${PM_STUDIO_ORIGIN}",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>\`req_\${Date.now()}_\${Math.random().toString(36).substr(2,9)}\`}};const c=fetch.bind(globalThis),n="${CCDX_PM_STUDIO_ORIGIN}",a="${PM_STUDIO_SPLIT_ORIGIN_MARKER}",h="X-CCDX-PM-Relay",d=new Set,m=I=>I.headers.get(h)===a,q=I=>AbortSignal.any([I,AbortSignal.timeout(750)].filter(Boolean)),f=(I,e=400)=>Response.json({error:{code:I}},{status:e,headers:{[h]:a}});globalThis.fetch=async(I,e)=>{const t=I.url||I+"";if(t===\`\${l.API_ENDPOINT}/models\`){try{const t=await c(\`\${n}/models\`,e);if(t.ok&&m(t))try{let I=await t.clone().json(),e=I.data||I;if(Array.isArray(e)){d.clear();for(const I of e)/anthropic/i.test(I.vendor||I.owned_by)&&d.add(I.id);return t}}catch{}t.body?.cancel?.()?.catch?.(()=>{})}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I}return c(I,e)}const s=t.startsWith(l.API_ENDPOINT)?t.slice(l.API_ENDPOINT.length):"";if("POST"===e?.method&&["/chat/completions","/responses","/embeddings"].includes(s)){let t="";try{t=(JSON.parse(e.body).model||"").trim()}catch{}if(d.has(t)||/^claude-/i.test(t)){if("/chat/completions"!==s)return f("model_not_supported");try{const I=await c(\`\${n}/models\`,{signal:q(e?.signal)}),t=401===I.status&&m(I);await I.text();if(!t)throw 0;const l=await c(\`\${n}\${s}\`,e);if(!m(l)){await l.body?.cancel?.();throw 0}return l}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I;return f("relay_incompatible",503)}}}return c(I,e)}}`;
@@ -326,6 +331,157 @@ export function blockSha256(buffer, blockSize) {
   return hashes;
 }
 
+function incompatibleAsar(message) {
+  const error = new Error(message);
+  error.code = "PM_STUDIO_ASAR_INCOMPATIBLE";
+  return error;
+}
+
+function requiredRecipeString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw incompatibleAsar(`PM Studio compatible recipe has no ${name}`);
+  }
+  return value;
+}
+
+export function createCompatiblePmStudioRecipe(value, options = {}) {
+  const parsed = parseAsarBuffer(value);
+  const entry = findAsarEntry(parsed.header, PM_STUDIO_COPILOT_CONFIG_MODULE_PATH);
+  if (!entry) throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} is missing`);
+
+  let targetOffset;
+  let targetSize;
+  let blockSize;
+  try {
+    targetOffset = entryOffset(entry.offset, `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} offset`);
+    targetSize = entrySize(entry.size, `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} size`);
+    blockSize = integer(entry.integrity?.blockSize,
+      `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} block size`);
+  } catch (error) {
+    throw incompatibleAsar(error.message);
+  }
+  const absoluteOffset = parsed.dataOffset + targetOffset;
+  if (entry.unpacked || entry.link || absoluteOffset + targetSize > parsed.buffer.length) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} is not one packed regular ASAR entry`);
+  }
+  if (blockSize === 0
+    || entry.integrity?.algorithm !== "SHA256"
+    || !sameArray(Object.keys(entry.integrity || {}).sort(), ["algorithm", "blockSize", "blocks", "hash"])) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has unsupported integrity metadata`);
+  }
+  const expectedBlockCount = Math.ceil(targetSize / blockSize);
+  if (targetSize > PM_STUDIO_COMPATIBLE_TARGET_MAX_BYTES
+    || blockSize < 16
+    || expectedBlockCount > PM_STUDIO_COMPATIBLE_BLOCK_MAX_COUNT
+    || entry.integrity.blocks.length !== expectedBlockCount) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has unsafe integrity block geometry`);
+  }
+
+  const sourceTarget = parsed.buffer.subarray(absoluteOffset, absoluteOffset + targetSize);
+  const sourceTargetSha256 = sha256Hex(sourceTarget);
+  const sourceBlocks = blockSha256(sourceTarget, blockSize);
+  if (entry.integrity.hash !== sourceTargetSha256
+    || !sameArray(entry.integrity.blocks, sourceBlocks)) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} integrity metadata does not match its bytes`);
+  }
+
+  const anchorPositions = occurrencePositions(
+    sourceTarget,
+    Buffer.from(PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR),
+  );
+  if (anchorPositions.length !== 1) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has ${anchorPositions.length} compatible module anchors, expected exactly one`);
+  }
+  const editOffset = anchorPositions[0];
+  const editEnd = editOffset + PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH;
+  if (editEnd > sourceTarget.length
+    || sha256Hex(sourceTarget.subarray(editOffset, editEnd))
+      !== PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256) {
+    throw incompatibleAsar("PM Studio Copilot configuration module is not the exact compatible source window");
+  }
+
+  const replacement = Buffer.from(PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE);
+  const patchedTarget = Buffer.from(sourceTarget);
+  replacement.copy(patchedTarget, editOffset);
+  const patchedTargetSha256 = sha256Hex(patchedTarget);
+  const patchedBlocks = blockSha256(patchedTarget, blockSize);
+  const patchedAsar = Buffer.from(parsed.buffer);
+  replacement.copy(patchedAsar, absoluteOffset + editOffset);
+  const patchedParsed = parseAsarBuffer(patchedAsar);
+  const patchedEntry = findAsarEntry(patchedParsed.header, PM_STUDIO_COPILOT_CONFIG_MODULE_PATH);
+  patchedEntry.integrity = {
+    ...patchedEntry.integrity,
+    algorithm: "SHA256",
+    hash: patchedTargetSha256,
+    blockSize,
+    blocks: [...patchedBlocks],
+  };
+  const patchedHeaderBytes = Buffer.from(JSON.stringify(patchedParsed.header));
+  if (patchedHeaderBytes.length !== patchedParsed.headerLength) {
+    throw incompatibleAsar(`Compatible ASAR header changed size (${patchedParsed.headerLength} -> ${patchedHeaderBytes.length})`);
+  }
+  patchedHeaderBytes.copy(patchedAsar, patchedParsed.headerStart);
+
+  const version = requiredRecipeString(String(options.version || ""), "version");
+  const build = requiredRecipeString(String(options.build || ""), "build");
+  const bundleIdentifier = requiredRecipeString(options.bundleIdentifier, "bundle identifier");
+  const sourceAsarSha256 = sha256Hex(parsed.buffer);
+  const identity = sha256Hex(`${PM_STUDIO_COMPATIBILITY_ID}\0${bundleIdentifier}\0${version}\0${build}\0${sourceAsarSha256}`).slice(0, 24);
+  const sourceBundleContent = options.sourceBundleContent
+    ? Object.freeze({
+      ...options.sourceBundleContent,
+      ignoredXattrs: Object.freeze([...(options.sourceBundleContent.ignoredXattrs || [])]),
+    })
+    : undefined;
+  const edit = Object.freeze({
+    offset: editOffset,
+    absoluteOffset: absoluteOffset + editOffset,
+    length: PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
+    anchor: PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR,
+    anchorCount: 1,
+    sourceSha256: PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256,
+    patchedSha256: sha256Hex(replacement),
+    replacement: PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE,
+  });
+  const target = Object.freeze({
+    path: PM_STUDIO_COPILOT_CONFIG_MODULE_PATH,
+    offset: targetOffset,
+    size: targetSize,
+    blockSize,
+    sourceSha256: sourceTargetSha256,
+    patchedSha256: patchedTargetSha256,
+    sourceBlocks: Object.freeze([...sourceBlocks]),
+    patchedBlocks: Object.freeze([...patchedBlocks]),
+    edit,
+  });
+  return Object.freeze({
+    id: `pm-studio-compatible-${identity}`,
+    compatibility: PM_STUDIO_COMPATIBILITY_ID,
+    version,
+    build,
+    bundleIdentifier,
+    sourceTeamIdentifier: requiredRecipeString(options.sourceTeamIdentifier, "source TeamIdentifier"),
+    executable: requiredRecipeString(options.executable, "executable"),
+    sourceExecutableSha256: requiredRecipeString(options.sourceExecutableSha256, "source executable SHA-256"),
+    electronFrameworkPath: requiredRecipeString(options.electronFrameworkPath, "Electron Framework path"),
+    sourceElectronFrameworkSha256: requiredRecipeString(
+      options.sourceElectronFrameworkSha256,
+      "source Electron Framework SHA-256",
+    ),
+    embeddedAsarIntegrity: requiredRecipeString(options.embeddedAsarIntegrity, "embedded ASAR integrity state"),
+    asarPath: requiredRecipeString(options.asarPath, "ASAR path"),
+    infoPlistPath: requiredRecipeString(options.infoPlistPath, "Info.plist path"),
+    integrityKey: requiredRecipeString(options.integrityKey, "ASAR integrity key"),
+    dataOffset: parsed.dataOffset,
+    sourceAsarSha256,
+    sourceHeaderSha256: sha256Hex(parsed.headerBytes),
+    patchedAsarSha256: sha256Hex(patchedAsar),
+    patchedHeaderSha256: sha256Hex(patchedHeaderBytes),
+    ...(sourceBundleContent ? { sourceBundleContent } : {}),
+    targets: Object.freeze([target]),
+  });
+}
+
 export function inspectElectronAsarIntegritySlots(value) {
   const buffer = checkedBuffer(value);
   const sentinel = Buffer.from(ELECTRON_ASAR_INTEGRITY_SENTINEL);