codex-copilot-dx 0.6.0 → 0.6.2

package/src/pm-studio-status.mjs

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  AUTH_PROFILE_CLAUDE,
+  readAuthProfileCredentials,
+} from "./auth-profile.mjs";
+import { PM_STUDIO_RECIPES } from "./pm-studio-asar.mjs";
+import {
+  createPmStudioSetupOperations,
+  DEFAULT_PM_STUDIO_APP_PATH,
+  inspectPmStudioApp,
+  PM_STUDIO_CLAUDE_AUTH_COMMAND,
+} from "./pm-studio-setup.mjs";
+import { checkRunningAdapter } from "./running-adapter.mjs";
+import { status } from "./status.mjs";
+
+const PM_RELAY_HOST = "127.0.0.1";
+const PM_RELAY_PORT = 2026;
+
+function selectRecipe(metadata, recipes) {
+  return recipes.find((recipe) => recipe.version === String(metadata.version)
+    && recipe.build === String(metadata.build)
+    && recipe.bundleIdentifier === String(metadata.bundleIdentifier));
+}
+
+function safeMessage(error) {
+  return String(error?.message || "inspection failed").replace(/\s+/g, " ").trim();
+}
+
+function inspectClaudeProfile(home, readCredentials) {
+  try {
+    const credentials = readCredentials(AUTH_PROFILE_CLAUDE, { home });
+    return {
+      configured: credentials.configured === true,
+      valid: credentials.valid === true,
+      reason: credentials.reason || "",
+      login: credentials.identity?.login || "",
+    };
+  } catch (error) {
+    return { configured: true, valid: false, reason: safeMessage(error), login: "" };
+  }
+}
+
+export async function inspectPmStudioStatus({
+  appPath = DEFAULT_PM_STUDIO_APP_PATH,
+  home = os.homedir(),
+  recipes = PM_STUDIO_RECIPES,
+  operationOverrides = {},
+  existsSync = fs.existsSync,
+  inspectApp = inspectPmStudioApp,
+  readClaudeCredentials = readAuthProfileCredentials,
+  checkRunningAdapterFn = checkRunningAdapter,
+} = {}) {
+  const operations = createPmStudioSetupOperations(operationOverrides);
+  let app;
+  if (!existsSync(appPath)) {
+    app = { state: "not_installed", metadata: null, issues: [] };
+  } else {
+    try {
+      const metadata = operations.readBundleMetadata({
+        appPath,
+        infoPlistPath: path.join(appPath, "Contents/Info.plist"),
+        processRunner: operations.processRunner,
+      });
+      const normalized = {
+        version: String(metadata.version),
+        build: String(metadata.build),
+        bundleIdentifier: String(metadata.bundleIdentifier),
+      };
+      const recipe = selectRecipe(normalized, recipes);
+      app = recipe
+        ? { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id }
+        : { state: "unsupported", metadata: normalized, issues: [], recipe: "" };
+    } catch (error) {
+      app = { state: "error", metadata: null, issues: [safeMessage(error)], recipe: "" };
+    }
+  }
+
+  const claude = inspectClaudeProfile(home, readClaudeCredentials);
+  let adapter;
+  try {
+    adapter = await checkRunningAdapterFn({ host: PM_RELAY_HOST, port: PM_RELAY_PORT });
+  } catch (error) {
+    adapter = { ok: false, error };
+  }
+  const operational = app.state === "patched" && claude.valid && adapter?.ok === true;
+  return { ok: operational, appPath, app, claude, adapter };
+}
+
+function appStatusLine(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("; ")}`);
+}
+
+export function formatPmStudioStatus(result, { commandName = "ccdx" } = {}) {
+  const lines = [
+    `${commandName} pms status`,
+    appStatusLine(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}`));
+  } 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}`));
+  }
+  if (result.adapter?.ok) {
+    lines.push(status("ok", `PM relay is available at ${result.adapter.baseUrl}`));
+  } else if (result.adapter?.incompatible) {
+    lines.push(status("err", `The adapter at ${result.adapter.baseUrl} is incompatible; stop it and run ${commandName} start`));
+  } else {
+    lines.push(status("warn", `PM relay is not running at http://${PM_RELAY_HOST}:${PM_RELAY_PORT}; run ${commandName} start`));
+  }
+  lines.push(status("info", "Routing: PM GPT uses the PM Studio bearer; eligible Claude chat uses the isolated Claude profile"));
+  return lines.join("\n");
+}
+
+export async function runPmStudioStatus(options = {}) {
+  const result = await inspectPmStudioStatus(options);
+  const output = formatPmStudioStatus(result, options);
+  (options.log || console.log)(output);
+  return { ...result, output };
+}

package/src/profile-model-runtime.mjs

@@ -33,6 +33,7 @@ export function createProfileModelRuntime({
   codexClient,
   claudeClient = codexClient,
   claudeMode = "inherited",
+  codexCredentialFingerprint = "",
   claudeCredentialFingerprint = "",
   home,
   env = process.env,
@@ -93,7 +94,7 @@ export function createProfileModelRuntime({
   function loadCached({ client, profile, registry, ownsClaudeModels }) {
     const credentialFingerprint = profile === "claude"
       ? String(claudeCredentialFingerprint || "").trim()
-      : "";
+      : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return false;
     const cached = loadModelCache({ home, profile, credentialFingerprint });
     if (!cached) return false;
@@ -133,7 +134,7 @@ export function createProfileModelRuntime({
   function persist(models, profile) {
     const credentialFingerprint = profile === "claude"
       ? String(claudeCredentialFingerprint || "").trim()
-      : "";
+      : String(codexCredentialFingerprint || "").trim();
     if (profile === "claude" && !credentialFingerprint) return;
     try {
       saveModelCache(models, { home, profile, credentialFingerprint });

package/src/profile-routing.mjs

@@ -0,0 +1,74 @@
+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" });
+}
+
+export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {}) {
+  if (typeof getCatalog !== "function") throw new Error("getCatalog is required");
+  if (typeof isClaudeEnabled !== "function") throw new Error("isClaudeEnabled is required");
+
+  const unset = Symbol("unset");
+  let cachedCatalog = unset;
+  let cachedEnabled = false;
+  let cachedAllowed = new Map();
+  let cachedKnown = new Set();
+  let rebuilds = 0;
+
+  function availability() {
+    const catalog = getCatalog();
+    const enabled = isClaudeEnabled() === true;
+    if (catalog === cachedCatalog && enabled === cachedEnabled) {
+      return { allowed: cachedAllowed, known: cachedKnown };
+    }
+
+    const allowed = new Map();
+    const known = new Set();
+    for (const model of catalogData(catalog)) {
+      const id = String(model?.id || "").trim();
+      if (!id || !isClaudeCatalogEntry(model)) continue;
+      known.add(id);
+      if (enabled && isAllowedClaudeModel(model) && !allowed.has(id)) allowed.set(id, model);
+    }
+    cachedCatalog = catalog;
+    cachedEnabled = enabled;
+    cachedAllowed = allowed;
+    cachedKnown = known;
+    rebuilds += 1;
+    return { allowed, known };
+  }
+
+  return Object.freeze({
+    classify(modelId) {
+      const id = String(modelId || "").trim();
+      const { allowed, known } = availability();
+      if (allowed.has(id)) return "claude";
+      if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
+      return "enterprise";
+    },
+    allowedModels() {
+      return [...availability().allowed.values()];
+    },
+    diagnostics() {
+      return { rebuilds, allowed: cachedAllowed.size, known: cachedKnown.size };
+    },
+  });
+}

package/src/profile-runtime.mjs

@@ -1,5 +1,6 @@
 import {
   AUTH_PROFILE_CLAUDE,
+  AUTH_PROFILE_CODEX,
   authProfilePaths,
   profileReauthMessage,
   readAuthProfileCredentials,
@@ -45,6 +46,16 @@ export function createProfileRuntime({
   };
   const credentials = readCredentials();
   const claudeProfile = safeProfileStatus(credentials);
+  let codexCredentialFingerprint = "";
+  try {
+    const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
+    if (codexCredentials.valid) {
+      codexCredentialFingerprint = githubTokenFingerprint(codexCredentials.token);
+    }
+  } catch {
+    // The Codex client remains authoritative if its optional metadata cannot
+    // be inspected; only credential-bound cache reuse is disabled.
+  }
 
   if (!credentials.configured) {
     return Object.freeze({
@@ -52,6 +63,7 @@ export function createProfileRuntime({
       claudeClient: codexClient,
       claudeMode: "inherited",
       claudeProfile,
+      codexCredentialFingerprint,
       claudeCredentialFingerprint: "",
     });
   }
@@ -73,6 +85,7 @@ export function createProfileRuntime({
     claudeClient,
     claudeMode: "isolated",
     claudeProfile,
+    codexCredentialFingerprint,
     claudeCredentialFingerprint: credentials.valid
       ? githubTokenFingerprint(credentials.token)
       : "",

package/src/running-adapter.mjs

@@ -5,6 +5,7 @@ export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
 export const ADAPTER_STATUS_PATH = "/_ccdx/status";
 export const ADAPTER_PROTOCOL_VERSION = 2;
 export const ADAPTER_VERSION = localPackageVersion();
+export const ADAPTER_CAPABILITIES = Object.freeze(["pm_studio_relay_v1"]);
 const ADAPTER_INSTANCE_ID = randomUUID();
 
 export function adapterHealthPayload() {
@@ -14,6 +15,7 @@ export function adapterHealthPayload() {
     pid: process.pid,
     version: ADAPTER_VERSION,
     protocol_version: ADAPTER_PROTOCOL_VERSION,
+    capabilities: [...ADAPTER_CAPABILITIES],
     instance_id: ADAPTER_INSTANCE_ID,
   };
 }
@@ -37,6 +39,7 @@ export async function checkRunningAdapter({
   timeoutMs = 500,
   expectedVersion = ADAPTER_VERSION,
   expectedProtocolVersion = ADAPTER_PROTOCOL_VERSION,
+  requiredCapabilities = ADAPTER_CAPABILITIES,
 } = {}) {
   const baseUrl = adapterBaseUrl(host, port);
   const ctrl = new AbortController();
@@ -62,6 +65,19 @@ export async function checkRunningAdapter({
         expectedProtocolVersion,
       };
     }
+    const capabilities = new Set(Array.isArray(data.capabilities) ? data.capabilities : []);
+    if (requiredCapabilities.some((capability) => !capabilities.has(capability))) {
+      return {
+        ok: false,
+        incompatible: true,
+        baseUrl,
+        status: resp.status,
+        data,
+        expectedVersion,
+        expectedProtocolVersion,
+        requiredCapabilities: [...requiredCapabilities],
+      };
+    }
     return { ok: true, baseUrl, data };
   } catch (e) {
     return { ok: false, baseUrl, error: e };