codex-copilot-dx 0.6.5 → 0.6.7

package/src/pm-studio-setup.mjs

@@ -396,6 +396,19 @@ function backupName(recipe) {
   return `${recipe.id}-${recipe.sourceAsarSha256.slice(0, 12)}`;
 }
 
+export function pmStudioBackupRoot(home = os.homedir()) {
+  return path.join(home, ".local", "share", "codex-copilot-dx", "pm-studio-backups");
+}
+
+export function pmStudioPatchManifestPath({
+  home = os.homedir(),
+  backupRoot = pmStudioBackupRoot(home),
+  recipe,
+} = {}) {
+  if (!recipe) throw new TypeError("PM Studio patch recipe is required");
+  return path.join(backupRoot, backupName(recipe), "manifest.json");
+}
+
 function backupManifest(recipe, createdAt) {
   return {
     schema_version: 1,
@@ -512,13 +525,24 @@ function writePatchedBinaryRecord({ backup, inspection, operations }) {
   backup.manifest = manifest;
 }
 
-function assertPatchedBinaryRecord({ inspection, manifestPath }) {
+export function assertPatchedBinaryRecord({ inspection, manifestPath, recipe }) {
   let manifest;
   try {
     manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
   } catch {
     throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record is missing or invalid");
   }
+  if (recipe && (manifest?.schema_version !== 1
+    || manifest?.kind !== "ccdx-pm-studio-backup"
+    || manifest?.recipe_id !== recipe.id
+    || manifest?.app?.bundle_identifier !== recipe.bundleIdentifier
+    || manifest?.app?.version !== recipe.version
+    || manifest?.app?.build !== recipe.build
+    || manifest?.patched?.asar_sha256 !== recipe.patchedAsarSha256
+    || manifest?.patched?.asar_header_sha256 !== recipe.patchedHeaderSha256
+    || !integrityMatches(manifest?.patched?.electron_asar_integrity, "SHA256", recipe.patchedHeaderSha256))) {
+    throw setupError("PM_STUDIO_PATCH_RECORD_INVALID", "PM Studio patched-binary record does not match the installed patch recipe");
+  }
   const binaries = manifest?.patched?.binaries;
   if (!binaries
     || binaries.main_executable_sha256 !== inspection.executableIntegrity.executableSha256
@@ -593,7 +617,7 @@ export async function runPmStudioSetup({
   commandName = "ccdx",
   appPath = DEFAULT_PM_STUDIO_APP_PATH,
   home = os.homedir(),
-  backupRoot = path.join(home, ".local", "share", "codex-copilot-dx", "pm-studio-backups"),
+  backupRoot = pmStudioBackupRoot(home),
   recipes = PM_STUDIO_RECIPES,
   operations: operationOverrides = {},
   logger = (line) => console.log(line),
@@ -629,7 +653,7 @@ export async function runPmStudioSetup({
       throw setupError("PM_STUDIO_BACKUP_INVALID", "Patched PM Studio has no matching verified backup; no files were changed");
     }
     const backup = validateBackup({ backupDir: finalBackupDir, recipe, operations });
-    assertPatchedBinaryRecord({ inspection: source, manifestPath: backup.manifestPath });
+    assertPatchedBinaryRecord({ inspection: source, manifestPath: backup.manifestPath, recipe });
     emit(`[OK] PM Studio ${recipe.version} build ${recipe.build} is already patched; no backup or signing was repeated.`);
     emit(`[OK] Verified backup: ${backup.backupAppPath}`);
     emit(`[OK] Backup manifest: ${backup.manifestPath}`);
@@ -700,7 +724,7 @@ export async function runPmStudioSetup({
         installed.issues);
     }
     try {
-      assertPatchedBinaryRecord({ inspection: installed, manifestPath: backup.manifestPath });
+      assertPatchedBinaryRecord({ inspection: installed, manifestPath: backup.manifestPath, recipe });
     } catch (error) {
       throw setupError("PM_STUDIO_INSTALL_VERIFY_FAILED",
         `Installed PM Studio differs from the verified staging record; do not launch it. ${recoveryMessage(backup)}`,

package/src/pm-studio-status.mjs

@@ -7,16 +7,33 @@ import {
 } from "./auth-profile.mjs";
 import { PM_STUDIO_RECIPES } from "./pm-studio-asar.mjs";
 import {
+  assertPatchedBinaryRecord,
   createPmStudioSetupOperations,
   DEFAULT_PM_STUDIO_APP_PATH,
   inspectPmStudioApp,
   PM_STUDIO_CLAUDE_AUTH_COMMAND,
+  pmStudioBackupRoot,
+  pmStudioPatchManifestPath,
 } from "./pm-studio-setup.mjs";
+import { readAdapterStatus } from "./cli-status.mjs";
 import { checkRunningAdapter } from "./running-adapter.mjs";
 import { status } from "./status.mjs";
+import {
+  cliOutputFormat,
+  cliOutputWidth,
+  formatResponsiveCliTable,
+  terminalCell,
+} from "./cli-table.mjs";
 
 const PM_RELAY_HOST = "127.0.0.1";
 const PM_RELAY_PORT = 2026;
+const PM_RELAY_CAPABILITY = "pm_studio_relay_v1";
+const PM_RELAY_ROUTE_NAMES = Object.freeze([
+  "pm_models",
+  "pm_chat_completions",
+  "pm_responses",
+  "pm_embeddings",
+]);
 
 function selectRecipe(metadata, recipes) {
   return recipes.find((recipe) => recipe.version === String(metadata.version)
@@ -42,15 +59,52 @@ function inspectClaudeProfile(home, readCredentials) {
   }
 }
 
+function inspectAdapterRuntime(adapter, runtimeStatus) {
+  const data = runtimeStatus?.data;
+  const health = adapter?.data;
+  const issues = [];
+  if (!data || typeof data !== "object") {
+    return { ok: false, baseUrl: runtimeStatus?.baseUrl || adapter?.baseUrl, data: null, issues: ["runtime status payload is missing"] };
+  }
+  if (data.version !== health?.version
+    || data.protocol_version !== health?.protocol_version
+    || data.instance_id !== health?.instance_id
+    || data.pid !== health?.pid) {
+    issues.push("health and runtime status do not describe the same adapter instance");
+  }
+  const capabilities = new Set(Array.isArray(data.capabilities) ? data.capabilities : []);
+  if (!capabilities.has(PM_RELAY_CAPABILITY)) issues.push("PM Studio relay capability is missing");
+  if (data.profiles?.claude?.mode !== "isolated") issues.push("Claude profile mode is not isolated");
+  if (data.profiles?.claude?.profile_current !== true) {
+    issues.push("running Claude credentials do not match the current isolated profile");
+  }
+  if (data.routing?.responses !== "codex") issues.push("/v1/responses is not routed to Codex");
+  if (data.routing?.messages !== "claude") issues.push("/v1/messages is not routed to Claude");
+  const routes = data.requests?.by_route;
+  for (const routeName of PM_RELAY_ROUTE_NAMES) {
+    if (!routes || typeof routes !== "object" || !Object.hasOwn(routes, routeName)) {
+      issues.push(`runtime status does not expose ${routeName}`);
+    }
+  }
+  return {
+    ...runtimeStatus,
+    ok: issues.length === 0,
+    issues,
+  };
+}
+
 export async function inspectPmStudioStatus({
   appPath = DEFAULT_PM_STUDIO_APP_PATH,
   home = os.homedir(),
+  backupRoot = pmStudioBackupRoot(home),
   recipes = PM_STUDIO_RECIPES,
   operationOverrides = {},
   existsSync = fs.existsSync,
   inspectApp = inspectPmStudioApp,
+  verifyPatchRecord = assertPatchedBinaryRecord,
   readClaudeCredentials = readAuthProfileCredentials,
   checkRunningAdapterFn = checkRunningAdapter,
+  readAdapterStatusFn = readAdapterStatus,
 } = {}) {
   const operations = createPmStudioSetupOperations(operationOverrides);
   let app;
@@ -69,9 +123,24 @@ export async function inspectPmStudioStatus({
         bundleIdentifier: String(metadata.bundleIdentifier),
       };
       const recipe = selectRecipe(normalized, recipes);
-      app = recipe
-        ? { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id }
-        : { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+      if (recipe) {
+        app = { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id };
+        if (app.state === "patched") {
+          const manifestPath = pmStudioPatchManifestPath({ home, backupRoot, recipe });
+          try {
+            verifyPatchRecord({ inspection: app, manifestPath, recipe });
+            app.patchRecord = { valid: true, manifestPath, reason: "" };
+          } catch (error) {
+            const reason = safeMessage(error);
+            app.patchRecipeMatched = true;
+            app.patchRecord = { valid: false, manifestPath, reason };
+            app.state = "drift";
+            app.issues = [...(Array.isArray(app.issues) ? app.issues : []), reason];
+          }
+        }
+      } else {
+        app = { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+      }
     } catch (error) {
       app = { state: "error", metadata: null, issues: [safeMessage(error)], recipe: "" };
     }
@@ -84,42 +153,125 @@ export async function inspectPmStudioStatus({
   } catch (error) {
     adapter = { ok: false, error };
   }
-  const operational = app.state === "patched" && claude.valid && adapter?.ok === true;
-  return { ok: operational, appPath, app, claude, adapter };
+  let runtime = { ok: false, baseUrl: adapter?.baseUrl, data: null, issues: ["adapter health check failed"] };
+  if (adapter?.ok === true) {
+    try {
+      runtime = inspectAdapterRuntime(adapter, await readAdapterStatusFn({
+        host: PM_RELAY_HOST,
+        port: PM_RELAY_PORT,
+      }));
+    } catch (error) {
+      runtime = { ok: false, baseUrl: adapter.baseUrl, data: null, issues: [safeMessage(error)] };
+    }
+  }
+  const operational = app.state === "patched"
+    && app.patchRecord?.valid === true
+    && claude.valid
+    && adapter?.ok === true
+    && runtime.ok === true;
+  return { ok: operational, appPath, app, claude, adapter, runtime };
 }
 
-function appStatusLine(result, commandName) {
+function appStatusItem(result, commandName) {
   const { app } = result;
   const version = app.metadata ? `${app.metadata.version} build ${app.metadata.build}` : "";
-  if (app.state === "patched") return status("ok", `PM Studio ${version} is patched and verified`);
-  if (app.state === "clean") return status("warn", `PM Studio ${version} is supported but not patched; run ${commandName} pms setup`);
-  if (app.state === "unsupported") return status("err", `PM Studio ${version} has no exact patch recipe; no files will be changed`);
-  if (app.state === "drift") return status("err", `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}`);
-  if (app.state === "not_installed") return status("warn", `PM Studio is not installed at ${result.appPath}`);
-  return status("err", `PM Studio could not be inspected: ${app.issues.join("; ")}`);
+  if (app.state === "patched" && app.patchRecord?.valid === true) {
+    return { kind: "ok", component: "App patch", detail: `${version}; patched and verified`, message: `PM Studio ${version} is patched and verified against its installed patch record` };
+  }
+  if (app.state === "patched") {
+    const reason = app.patchRecord?.reason || "installed patch record is missing";
+    return { kind: "err", component: "App patch", detail: `${version}; patch record not verified`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${reason}` };
+  }
+  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; supported, not patched`, message: `PM Studio ${version} is supported but not patched; run ${commandName} pms setup` };
+  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; unsupported version`, message: `PM Studio ${version} has no exact patch recipe; no files will be changed` };
+  if (app.state === "drift" && app.patchRecipeMatched) {
+    return { kind: "err", component: "App patch", detail: `${version}; patch record drift`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}` };
+  }
+  if (app.state === "drift") return { kind: "err", component: "App patch", detail: `${version}; integrity drift`, message: `PM Studio ${version} does not match the clean or patched recipe: ${app.issues.join("; ")}` };
+  if (app.state === "not_installed") return { kind: "warn", component: "App patch", detail: "not installed", message: `PM Studio is not installed at ${result.appPath}` };
+  return { kind: "err", component: "App patch", detail: "inspection failed", message: `PM Studio could not be inspected: ${app.issues.join("; ")}` };
 }
 
-export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
-  const lines = [
-    `${commandName} pms status`,
-    appStatusLine(result, commandName),
-  ];
+function pmStudioStatusItems(result, commandName) {
+  const items = [appStatusItem(result, commandName)];
   if (result.claude.valid) {
     const account = result.claude.login ? ` for ${result.claude.login}` : "";
-    lines.push(status("ok", `Isolated Claude profile is valid${account}`));
+    const detail = result.claude.login ? `${result.claude.login}; isolated profile valid` : "isolated profile valid";
+    items.push({ kind: "ok", component: "Claude profile", detail, message: `Isolated Claude profile is valid${account}` });
   } else {
     const reason = result.claude.configured && result.claude.reason ? ` (${result.claude.reason})` : "";
-    lines.push(status("err", `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}`));
+    items.push({ kind: "err", component: "Claude profile", detail: "not ready", message: `Isolated Claude profile is not ready${reason}; run ${PM_STUDIO_CLAUDE_AUTH_COMMAND}` });
   }
-  if (result.adapter?.ok) {
-    lines.push(status("ok", `PM relay is available at ${result.adapter.baseUrl}`));
+  if (result.adapter?.ok && result.runtime?.ok) {
+    items.push({ kind: "ok", component: "PM relay", detail: `verified at ${result.adapter.baseUrl}`, message: `PM relay and isolated Claude routing are verified at ${result.adapter.baseUrl}` });
+  } else if (result.adapter?.ok) {
+    const reason = result.runtime?.issues?.join("; ") || "runtime status is unavailable";
+    items.push({ kind: "err", component: "PM relay", detail: "running but routing not ready", message: `The adapter is running at ${result.adapter.baseUrl}, but PM relay routing is not ready: ${reason}; stop it and run ${commandName} start` });
   } else if (result.adapter?.incompatible) {
-    lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
+    items.push({ kind: "err", component: "PM relay", detail: `incompatible at ${result.adapter.baseUrl}`, message: `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start` });
+  } else {
+    items.push({ kind: "warn", component: "PM relay", detail: `not running at ${PM_RELAY_HOST}:${PM_RELAY_PORT}`, message: `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start` });
+  }
+  if (result.runtime?.ok) {
+    items.push({ kind: "info", component: "Routing", detail: "GPT -> PM bearer; Claude -> isolated profile", message: "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
   } else {
-    lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
+    items.push({ kind: "info", component: "Routing", detail: "expected: GPT -> PM bearer; Claude -> isolated profile", message: "Expected routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile" });
+  }
+  return items;
+}
+
+function formatPmStudioStatusPlain(result, commandName, { sanitize = false } = {}) {
+  const lines = [
+    `${commandName} pms status`,
+    ...pmStudioStatusItems(result, commandName).map((item) => status(item.kind, item.message)),
+  ];
+  return (sanitize ? lines.map((line) => terminalCell(line, { fallback: "" })) : lines).join("\n");
+}
+
+function tableState(kind) {
+  return `[${String(kind).toUpperCase()}]`;
+}
+
+function formatPmStudioStatusTable(result, { commandName, output }) {
+  const items = pmStudioStatusItems(result, commandName);
+  const rows = items.map((item) => ({
+    component: item.component,
+    state: tableState(item.kind),
+    detail: item.detail,
+  }));
+  const table = formatResponsiveCliTable({
+    columns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+      { key: "detail", label: "DETAIL" },
+    ],
+    compactColumns: [
+      { key: "component", label: "COMPONENT" },
+      { key: "state", label: "STATE" },
+    ],
+    rows,
+    width: cliOutputWidth(output),
+  });
+  const lines = [`${commandName} pms status`, table.output];
+  const details = table.compact ? items : items.filter((item) => item.kind === "warn" || item.kind === "err");
+  if (details.length) {
+    lines.push("", "Details:", ...details.map((item) => terminalCell(status(item.kind, item.message), { fallback: "" })));
+  }
+  return { output: lines.join("\n"), overflow: table.overflow };
+}
+
+export function formatPmStudioStatus(result, {
+  commandName = "ccdx",
+  format = "plain",
+  output = process.stdout,
+} = {}) {
+  if (cliOutputFormat(format, output) === "plain") {
+    return formatPmStudioStatusPlain(result, commandName);
   }
-  lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
-  return lines.join("\n");
+  const table = formatPmStudioStatusTable(result, { commandName, output });
+  return format === "auto" && table.overflow
+    ? formatPmStudioStatusPlain(result, commandName, { sanitize: true })
+    : table.output;
 }
 
 export async function runPmStudioStatus(options = {}) {

package/src/profile-routing.mjs

@@ -1,22 +1,13 @@
+import {
+  isClaudeCopilotCatalogEntry,
+  isClaudeCopilotModel,
+} from "./models.mjs";
+
 function catalogData(catalog) {
   if (Array.isArray(catalog)) return catalog;
   return Array.isArray(catalog?.data) ? catalog.data : [];
 }
 
-function isClaudeCatalogEntry(model) {
-  const id = String(model?.id || "").trim();
-  const vendor = String(model?.vendor || "").trim().toLowerCase();
-  return Boolean(id) && (vendor === "anthropic" || id.toLowerCase().startsWith("claude-"));
-}
-
-function isAllowedClaudeModel(model) {
-  return isClaudeCatalogEntry(model)
-    && String(model?.vendor || "").trim().toLowerCase() === "anthropic"
-    && model?.model_picker_enabled !== false
-    && Array.isArray(model?.supported_endpoints)
-    && model.supported_endpoints.includes("/chat/completions");
-}
-
 export function profileRouting({ claudeMode = "inherited", claudeConfigured = false } = {}) {
   const isolated = claudeMode === "isolated" || claudeConfigured === true;
   return Object.freeze({ responses: "codex", messages: isolated ? "claude" : "codex" });
@@ -44,9 +35,9 @@ export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {})
     const known = new Set();
     for (const model of catalogData(catalog)) {
       const id = String(model?.id || "").trim();
-      if (!id || !isClaudeCatalogEntry(model)) continue;
+      if (!id || !isClaudeCopilotCatalogEntry(model)) continue;
       known.add(id);
-      if (enabled && isAllowedClaudeModel(model) && !allowed.has(id)) allowed.set(id, model);
+      if (enabled && isClaudeCopilotModel(model) && !allowed.has(id)) allowed.set(id, model);
     }
     cachedCatalog = catalog;
     cachedEnabled = enabled;

package/src/profile-runtime.mjs

@@ -46,6 +46,15 @@ export function createProfileRuntime({
   };
   const credentials = readCredentials();
   const claudeProfile = safeProfileStatus(credentials);
+  const claudeCredentialFingerprint = credentials.valid
+    ? githubTokenFingerprint(credentials.token)
+    : "";
+  const isClaudeProfileCurrent = () => {
+    if (!claudeCredentialFingerprint) return false;
+    const current = readCredentials();
+    return current.valid === true
+      && githubTokenFingerprint(current.token) === claudeCredentialFingerprint;
+  };
   let codexCredentialFingerprint = "";
   try {
     const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
@@ -65,6 +74,7 @@ export function createProfileRuntime({
       claudeProfile,
       codexCredentialFingerprint,
       claudeCredentialFingerprint: "",
+      isClaudeProfileCurrent,
     });
   }
 
@@ -86,8 +96,7 @@ export function createProfileRuntime({
     claudeMode: "isolated",
     claudeProfile,
     codexCredentialFingerprint,
-    claudeCredentialFingerprint: credentials.valid
-      ? githubTokenFingerprint(credentials.token)
-      : "",
+    claudeCredentialFingerprint,
+    isClaudeProfileCurrent,
   });
 }

package/src/response-history.mjs

@@ -1,4 +1,5 @@
 import { httpError } from "./http-transport.mjs";
+import { clearResponsesToolOutputPartsCache } from "./responses-content.mjs";
 import { loadRuntimeConfig, parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
 const DEFAULT_MAX_BYTES = RUNTIME_DEFAULTS.responseHistoryMaxBytes;
@@ -201,17 +202,26 @@ export function responseHistoryMaterializedBytes(responseId) {
   return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
 }
 
-export function materializeResponseHistory(responseId) {
+export function materializeResponseHistory(responseId, { assertActive } = {}) {
+  assertActive?.();
   const { chain, rootId } = responseHistoryChain(responseId);
   const items = [];
-  for (const entry of chain.reverse()) items.push(...entry.inputItems, ...entry.outputItems);
+  for (let index = 0; index < chain.length; index += 1) {
+    if ((index & 63) === 0) assertActive?.();
+    const entry = chain[chain.length - index - 1];
+    items.push(...entry.inputItems, ...entry.outputItems);
+  }
+  assertActive?.();
   const materialized = cloneJson(items);
+  assertActive?.();
   touchTree(rootId);
   return materialized;
 }
 
 export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
   if (!id || !Array.isArray(inputItems)) return;
+  clearResponsesToolOutputPartsCache(inputItems);
+  clearResponsesToolOutputPartsCache(outputItems);
   const bytes = jsonByteLength([inputItems, outputItems]);
   if (bytes > maxBytes) {
     if (histories.has(id)) removeSubtree(id);