minecodex 0.1.14 → 0.1.16

package/README.md

@@ -26,6 +26,8 @@ mcx install
 
 运行 `mcx install` 不会强制关闭或启动 Codex，也不会影响当前打开的窗口。安装完成后，终端会说明更改将在下一次重启 Codex 时生效，并询问是否立即重启；默认选项为 **No**。只有在您明确确认，或后续手动运行 `mcx restart` 时，才会重新打开 Codex。安装完成后，macOS 的“登录项与扩展”中会添加名为 **MineCodex** 的后台项目。
 
+MineCodex 只以后台辅助服务运行，前台应用始终是 OpenAI 签名的官方 `ChatGPT.app`，并继续使用官方默认用户数据。通过 Dock、Finder、Spotlight、登录项或会话恢复打开 ChatGPT 时，后台服务会验证官方应用与对应进程；若该进程尚未开放兼容的本机调试端口，则确认其完整退出后再通过 LaunchServices 重新打开官方应用并注入功能。MineCodex 不修改 `ChatGPT.app`、`app.asar`、Dock 项目或默认打开方式。
+
 打开本地控制台：
 
 ```bash

package/features/model-slider/codex-feature.json

@@ -18,6 +18,7 @@
     "favoriteStorageKey": "codex-model-slider:favorites:v1",
     "providerAliases": {
       "opencode-go": "OpenCode Go",
+      "packyapi": "PackyAPI",
       "xai": "xAI",
       "zhipu": "Zhipu AI",
       "google": "Google",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecodex",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Lightweight, local-first plugins for the Codex desktop app.",
   "license": "MIT",
   "type": "module",

package/packages/cli/src/chatgpt-launch-coordinator.mjs

@@ -0,0 +1,77 @@
+function hasExactArgument(command, argument) {
+  const value = String(command);
+  let offset = value.indexOf(argument);
+  while (offset >= 0) {
+    const before = offset === 0 || /\s/.test(value[offset - 1]);
+    const end = offset + argument.length;
+    const after = end === value.length || /\s/.test(value[end]);
+    if (before && after) return true;
+    offset = value.indexOf(argument, offset + 1);
+  }
+  return false;
+}
+
+export function hasLoopbackCdpArguments(command, cdpPort) {
+  return hasExactArgument(command, "--remote-debugging-address=127.0.0.1")
+    && hasExactArgument(command, `--remote-debugging-port=${cdpPort}`)
+    && hasExactArgument(command, `--remote-allow-origins=http://127.0.0.1:${cdpPort}`);
+}
+
+function requireProcess(processInfo, context) {
+  if (!processInfo || !Number.isInteger(processInfo.pid) || processInfo.pid <= 1) {
+    throw new Error(`MineCodex could not verify the ${context} ChatGPT process.`);
+  }
+  if (typeof processInfo.command !== "string" || !processInfo.command.trim()) {
+    throw new Error(`MineCodex could not verify the ${context} ChatGPT command line.`);
+  }
+  if (processInfo.verified === false) {
+    throw new Error(`MineCodex rejected an unverified ${context} ChatGPT process.`);
+  }
+}
+
+export class ChatGPTLaunchCoordinator {
+  constructor({ platform, cdpPort }) {
+    this.platform = platform;
+    this.cdpPort = cdpPort;
+  }
+
+  async attach(processInfo, owned, { startRuntime, waitForHealthy }) {
+    requireProcess(processInfo, owned ? "LaunchServices-created" : "observed");
+    await this.platform.assertNativeCodexCdp(processInfo, this.cdpPort);
+    const status = await startRuntime();
+    const healthy = await waitForHealthy(status);
+    await this.platform.assertNativeCodexCdp(processInfo, this.cdpPort);
+    return {
+      ...healthy,
+      codex: { pid: processInfo.pid, owned, command: processInfo.command ?? null },
+    };
+  }
+
+  async ensureObservedLaunch(processInfo, { stopRuntime, startRuntime, waitForHealthy }) {
+    requireProcess(processInfo, "observed");
+    if (typeof this.platform?.terminateNativeCodex !== "function"
+      || typeof this.platform?.openNativeCodex !== "function"
+      || typeof this.platform?.assertNativeCodexCdp !== "function") {
+      throw new Error("MineCodex platform adapter cannot coordinate an official ChatGPT launch.");
+    }
+
+    await stopRuntime();
+    if (hasLoopbackCdpArguments(processInfo.command, this.cdpPort)) {
+      return this.attach(processInfo, false, { startRuntime, waitForHealthy });
+    }
+
+    const terminated = await this.platform.terminateNativeCodex(processInfo.pid, processInfo.command);
+    if (terminated !== 1) {
+      throw new Error(`MineCodex refused to replace ChatGPT pid ${processInfo.pid} after identity changed.`);
+    }
+    const launched = await this.platform.openNativeCodex({ cdpPort: this.cdpPort });
+    return this.attach(launched, true, { startRuntime, waitForHealthy });
+  }
+
+  async relaunchOwned({ stopRuntime, terminateOwned, startRuntime, waitForHealthy }) {
+    await stopRuntime();
+    await terminateOwned();
+    const launched = await this.platform.openNativeCodex({ cdpPort: this.cdpPort });
+    return this.attach(launched, true, { startRuntime, waitForHealthy });
+  }
+}

package/packages/cli/src/control-server.mjs

@@ -290,11 +290,13 @@ export async function createControlServer({
           service: { running: true },
           runtime: {
             running: runtime.running,
+            healthy: runtime.healthy === true,
             pid: runtime.pid ?? null,
             runtimeSessionId: runtime.runtimeSessionId ?? null,
             ready: runtime.ready ?? null,
             plugins: runtime.plugins ?? runtime.pluginStates ?? [],
             renderer: runtime.renderer ?? null,
+            codex: runtime.codex ?? null,
             failures: runtime.failures ?? [],
           },
           runtimeSessionId: runtime.runtimeSessionId ?? null,

package/packages/cli/src/platform.mjs

@@ -3,6 +3,7 @@ import { mkdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/pr
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
+import { hasLoopbackCdpArguments } from "./chatgpt-launch-coordinator.mjs";
 
 const defaultExecFile = promisify(execFileCallback);
 const defaultFileSystem = Object.freeze({ mkdir, readFile, rename, rm, stat, unlink, writeFile });
@@ -11,6 +12,8 @@ export const SERVICE_LABEL = "com.vontean.minecodex.background";
 export const LEGACY_SERVICE_LABEL = "com.vontean.minecodex";
 export const CODEX_APP_PATH = "/Applications/ChatGPT.app";
 export const CODEX_EXECUTABLE = `${CODEX_APP_PATH}/Contents/MacOS/ChatGPT`;
+export const CODEX_BUNDLE_IDENTIFIER = "com.openai.codex";
+export const CODEX_TEAM_IDENTIFIER = "2DC432GLL2";
 export const MIN_NODE_VERSION = Object.freeze({ major: 22, minor: 5, patch: 0 });
 export const MIN_MACOS_VERSION = Object.freeze({ major: 13, darwinMajor: 22 });
 
@@ -90,6 +93,40 @@ export async function resolveCodexInstallation({
   );
 }
 
+export async function verifyCodexInstallation({ installation, execFile = defaultExecFile } = {}) {
+  if (!installation?.appPath || !installation?.executable) {
+    throw new Error("Codex Desktop installation is incomplete.");
+  }
+  const infoPath = path.join(installation.appPath, "Contents", "Info.plist");
+  const { stdout: bundleIdentifier } = await execFile("/usr/bin/plutil", [
+    "-extract", "CFBundleIdentifier", "raw", "-o", "-", infoPath,
+  ]);
+  if (String(bundleIdentifier).trim() !== CODEX_BUNDLE_IDENTIFIER) {
+    throw new Error(`Refusing non-official ChatGPT bundle: ${String(bundleIdentifier).trim() || "unknown"}`);
+  }
+  await execFile("/usr/bin/codesign", ["--verify", "--deep", "--strict", installation.appPath]);
+  const { stderr: details } = await execFile("/usr/bin/codesign", [
+    "-dv", "--verbose=4", installation.appPath,
+  ]);
+  const authority = String(details).match(/^Authority=(.+)$/m)?.[1] ?? "";
+  const identifier = String(details).match(/^Identifier=(.+)$/m)?.[1] ?? "";
+  const teamIdentifier = String(details).match(/^TeamIdentifier=(.+)$/m)?.[1] ?? "";
+  if (
+    identifier !== CODEX_BUNDLE_IDENTIFIER
+    || teamIdentifier !== CODEX_TEAM_IDENTIFIER
+    || !/\bOpenAI\b/i.test(authority)
+  ) {
+    throw new Error("Refusing ChatGPT with an unexpected signing identity.");
+  }
+  return Object.freeze({
+    ...installation,
+    bundleIdentifier: CODEX_BUNDLE_IDENTIFIER,
+    signingIdentity: authority,
+    teamIdentifier,
+    verified: true,
+  });
+}
+
 export function parseProcessList(output) {
   return String(output).split("\n").flatMap((line) => {
     const match = line.match(/^\s*(\d+)\s+(.+)$/);
@@ -116,6 +153,22 @@ function hasManagedProfile(command, profileDir) {
   return false;
 }
 
+function extractCdpPort(command) {
+  const match = String(command).match(/(?:^|\s)--remote-debugging-port=(\d+)(?:\s|$)/);
+  return match ? Number(match[1]) : null;
+}
+
+function parseCodexOwnerMarker(content) {
+  try {
+    const marker = JSON.parse(String(content));
+    if (marker?.version !== 1 || !Number.isInteger(marker.pid) || marker.pid <= 1) return null;
+    if (typeof marker.command !== "string" || !marker.command.trim()) return null;
+    return marker;
+  } catch {
+    return null;
+  }
+}
+
 export function serviceIsAbsent(error) {
   return /could not find service|service not found|no such process|domain does not support specified action/i.test(
     `${error?.stderr ?? ""}\n${error?.message ?? ""}`,
@@ -136,6 +189,48 @@ async function waitForProcessExit(pid, { processApi, timeoutMs = 8_000, sleep =
   throw new Error(`Process ${pid} did not exit in time`);
 }
 
+async function waitForProcessesExit(
+  pids,
+  { processApi, timeoutMs = 8_000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)) },
+) {
+  const pending = new Set(pids);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    for (const pid of pending) {
+      try {
+        processApi.kill(pid, 0);
+      } catch (error) {
+        if (error.code === "ESRCH") pending.delete(pid);
+        else throw error;
+      }
+    }
+    if (pending.size === 0) return;
+    await sleep(100);
+  }
+  throw new Error(`ChatGPT process tree did not exit in time: ${[...pending].join(", ")}`);
+}
+
+function descendantPids(output, rootPid) {
+  const childrenByParent = new Map();
+  for (const line of String(output).split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(\d+)\s+/);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    const parentPid = Number(match[2]);
+    const children = childrenByParent.get(parentPid) ?? [];
+    children.push(pid);
+    childrenByParent.set(parentPid, children);
+  }
+  const descendants = [];
+  const pending = [...(childrenByParent.get(rootPid) ?? [])];
+  while (pending.length) {
+    const pid = pending.shift();
+    descendants.push(pid);
+    pending.push(...(childrenByParent.get(pid) ?? []));
+  }
+  return descendants;
+}
+
 function serviceTarget(uid) {
   return `gui/${uid}/${SERVICE_LABEL}`;
 }
@@ -169,7 +264,7 @@ export class MacPlatformAdapter {
     execFile = defaultExecFile,
     fileSystem = defaultFileSystem,
     processApi = process,
-    sleep,
+    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     codexInstallation,
   } = {}) {
     this.uid = uid;
@@ -181,6 +276,8 @@ export class MacPlatformAdapter {
     this.processApi = processApi;
     this.sleep = sleep;
     this.codexInstallation = codexInstallation;
+    this.codexInstallationFingerprint = null;
+    this.codexInstallationInjected = Boolean(codexInstallation);
   }
 
   assertInstallSupported() {
@@ -194,7 +291,7 @@ export class MacPlatformAdapter {
   }
 
   async assertCodexInstalled() {
-    this.codexInstallation = await resolveCodexInstallation({
+    const installation = await resolveCodexInstallation({
       homeDir: this.homeDir,
       fileExists: async (filePath) => {
         try {
@@ -206,11 +303,36 @@ export class MacPlatformAdapter {
         }
       },
     });
+    this.codexInstallation = await verifyCodexInstallation({ installation, execFile: this.execFile });
+    this.codexInstallationFingerprint = await this.readCodexInstallationFingerprint(this.codexInstallation);
+    this.codexInstallationInjected = false;
     return this.codexInstallation;
   }
 
   async codex() {
-    return this.codexInstallation ?? this.assertCodexInstalled();
+    if (!this.codexInstallation) return this.assertCodexInstalled();
+    if (this.codexInstallationInjected) return this.codexInstallation;
+    const currentFingerprint = await this.readCodexInstallationFingerprint(this.codexInstallation);
+    if (this.codexInstallationFingerprint == null) {
+      this.codexInstallationFingerprint = currentFingerprint;
+    } else if (currentFingerprint !== this.codexInstallationFingerprint) {
+      return this.assertCodexInstalled();
+    }
+    return this.codexInstallation;
+  }
+
+  async readCodexInstallationFingerprint(installation) {
+    if (typeof this.fileSystem.stat !== "function") return null;
+    const paths = [
+      installation.executable,
+      path.join(installation.appPath, "Contents", "Info.plist"),
+      path.join(installation.appPath, "Contents", "_CodeSignature", "CodeResources"),
+    ];
+    const records = await Promise.all(paths.map(async (filePath) => {
+      const info = await this.fileSystem.stat(filePath);
+      return [filePath, info.dev ?? null, info.ino ?? null, info.size ?? null, info.mtimeMs ?? null];
+    }));
+    return JSON.stringify(records);
   }
 
   async isLaunchdServiceRunning(target) {
@@ -428,12 +550,34 @@ export class MacPlatformAdapter {
   async listCodexProcesses() {
     const installation = await this.codex();
     const { stdout } = await this.execFile("/bin/ps", ["-axo", "pid=,command="]);
-    return parseProcessList(stdout).filter(({ command }) => isExactCodexProcess(command, installation));
+    return parseProcessList(stdout)
+      .filter(({ command }) => isExactCodexProcess(command, installation))
+      .map((processInfo) => ({
+        ...processInfo,
+        appPath: installation.appPath,
+        executable: installation.executable,
+        bundleIdentifier: installation.bundleIdentifier ?? CODEX_BUNDLE_IDENTIFIER,
+        signingIdentity: installation.signingIdentity ?? null,
+        verified: installation.verified !== false,
+      }));
   }
 
   async ownedCodexProcesses(paths) {
     const processes = await this.listCodexProcesses();
-    return processes.filter(({ command }) => hasManagedProfile(command, paths.profileDir));
+    let marker = null;
+    try {
+      marker = parseCodexOwnerMarker(await this.fileSystem.readFile(paths.codexPidPath, "utf8"));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    return processes.filter(({ pid, command, verified }) => verified === true && (
+      hasManagedProfile(command, paths.profileDir)
+      || (
+        pid === marker?.pid
+        && command === marker.command
+        && hasLoopbackCdpArguments(command, extractCdpPort(command))
+      )
+    ));
   }
 
   async assertOwnedCodexStopped(paths) {
@@ -457,45 +601,92 @@ export class MacPlatformAdapter {
   }
 
   async terminateOwnedCodex(paths) {
-    let pid;
-    try {
-      pid = Number((await this.fileSystem.readFile(paths.codexPidPath, "utf8")).trim());
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        await this.assertOwnedCodexStopped(paths);
-        return false;
-      }
-      throw error;
-    }
-    if (!Number.isInteger(pid) || pid <= 1) {
-      await this.assertOwnedCodexStopped(paths);
-      return false;
-    }
-    const processInfo = (await this.ownedCodexProcesses(paths)).find((candidate) => candidate.pid === pid);
+    const processInfo = (await this.ownedCodexProcesses(paths))[0];
     if (!processInfo) {
       await this.assertOwnedCodexStopped(paths);
       return false;
     }
-    this.processApi.kill(pid, "SIGTERM");
-    await waitForProcessExit(pid, { processApi: this.processApi, sleep: this.sleep });
+    this.processApi.kill(processInfo.pid, "SIGTERM");
+    await waitForProcessExit(processInfo.pid, { processApi: this.processApi, sleep: this.sleep });
     await this.fileSystem.unlink(paths.codexPidPath).catch(() => {});
     await this.assertOwnedCodexStopped(paths);
     return true;
   }
 
-  async terminateNativeCodex() {
-    const processes = (await this.listCodexProcesses()).filter(({ command }) => !command.includes("--user-data-dir="));
-    for (const { pid } of processes) this.processApi.kill(pid, "SIGTERM");
-    await Promise.all(processes.map(({ pid }) => waitForProcessExit(pid, { processApi: this.processApi, sleep: this.sleep })));
-    return processes.length;
+  async terminateNativeCodex(pid, expectedCommand = null) {
+    if (!Number.isInteger(pid) || pid <= 1) {
+      throw new Error("MineCodex requires an exact ChatGPT PID to terminate.");
+    }
+    const processInfo = (await this.listCodexProcesses()).find((candidate) => (
+      candidate.pid === pid
+      && candidate.verified === true
+      && !candidate.command.includes("--user-data-dir=")
+      && (!expectedCommand || candidate.command === expectedCommand)
+    ));
+    if (!processInfo) return 0;
+    const { stdout: processTree } = await this.execFile("/bin/ps", ["-axo", "pid=,ppid=,command="]);
+    const ownedProcessTree = [pid, ...descendantPids(processTree, pid)];
+    this.processApi.kill(pid, "SIGTERM");
+    await waitForProcessesExit(ownedProcessTree, { processApi: this.processApi, sleep: this.sleep });
+    return 1;
+  }
+
+  async assertNativeCodexCdp(processInfo, cdpPort) {
+    if (!processInfo?.verified || !Number.isInteger(processInfo.pid) || !hasLoopbackCdpArguments(processInfo.command, cdpPort)) {
+      throw new Error("MineCodex could not bind the loopback CDP endpoint to a verified ChatGPT process.");
+    }
+    const { stdout } = await this.execFile("/usr/sbin/lsof", [
+      "-nP", "-a", "-p", String(processInfo.pid), `-iTCP:${cdpPort}`, "-sTCP:LISTEN", "-Fn",
+    ]);
+    const fields = String(stdout).split("\n");
+    if (!fields.includes(`p${processInfo.pid}`) || !fields.includes(`n127.0.0.1:${cdpPort}`)) {
+      throw new Error(`ChatGPT pid ${processInfo.pid} does not own loopback CDP port ${cdpPort}.`);
+    }
+    return true;
   }
 
   async openBrowser(url) {
     await this.execFile("/usr/bin/open", [url]);
   }
 
-  async openNativeCodex() {
+  async openNativeCodex({ cdpPort } = {}) {
     const installation = await this.codex();
-    await this.execFile("/usr/bin/open", ["-a", installation.appPath]);
+    if (!Number.isInteger(cdpPort) || cdpPort <= 0 || cdpPort > 65_535) {
+      await this.execFile("/usr/bin/open", ["-a", installation.appPath]);
+      return null;
+    }
+    const existingPids = new Set((await this.listCodexProcesses()).map(({ pid }) => pid));
+    await this.execFile("/usr/bin/open", [
+      "-n",
+      "-a",
+      installation.appPath,
+      "--args",
+      "--remote-debugging-address=127.0.0.1",
+      `--remote-debugging-port=${cdpPort}`,
+      `--remote-allow-origins=http://127.0.0.1:${cdpPort}`,
+    ]);
+    return this.waitForNativeCodex({ cdpPort, excludedPids: existingPids });
+  }
+
+  async waitForNativeCodex({ cdpPort, excludedPids = new Set(), timeoutMs = 15_000 } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const candidates = (await this.listCodexProcesses()).filter(({ pid, command, verified }) => (
+        verified === true
+        && !excludedPids.has(pid)
+        && !command.includes("--user-data-dir=")
+        && hasLoopbackCdpArguments(command, cdpPort)
+      ));
+      if (candidates.length > 1) {
+        throw new Error(`LaunchServices exposed multiple new ChatGPT processes on CDP port ${cdpPort}.`);
+      }
+      const processInfo = candidates[0];
+      if (processInfo) {
+        await this.assertNativeCodexCdp(processInfo, cdpPort);
+        return processInfo;
+      }
+      await this.sleep?.(50);
+    }
+    throw new Error(`LaunchServices did not expose a loopback CDP ChatGPT process on port ${cdpPort}.`);
   }
 }