minecodex 1.0.10 → 1.1.0

package/packages/cli/src/platform.mjs

@@ -14,8 +14,10 @@ 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 CODEX_WINDOWS_PACKAGE_FAMILY = "OpenAI.Codex_2p2nqsd0c76g0";
 export const MIN_NODE_VERSION = Object.freeze({ major: 22, minor: 5, patch: 0 });
 export const MIN_MACOS_VERSION = Object.freeze({ major: 13, darwinMajor: 22 });
+export const WINDOWS_SERVICE_TASK_NAME = "MineCodex";
 
 function xml(value) {
   return String(value)
@@ -175,6 +177,59 @@ export function serviceIsAbsent(error) {
   );
 }
 
+// PowerShell 统一经 -EncodedCommand 执行：base64(UTF-16LE) 规避引号与编码问题。
+function encodePowerShellCommand(script) {
+  return Buffer.from(String(script), "utf16le").toString("base64");
+}
+
+// Windows 控制台默认代码页不是 UTF-8，脚本内强制统一输出编码，
+// 保证中文用户名等路径在 node 侧按 utf8 解码不失真。
+const POWERSHELL_PREAMBLE = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; $ErrorActionPreference = 'Stop';";
+
+export function isExactCodexProcessWindows(command, installation) {
+  const executable = String(installation?.executable ?? "");
+  if (!executable) return false;
+  const value = String(command ?? "").trim();
+  if (!value) return false;
+  // Electron 子进程使用同一 exe，接管列表只能包含主进程。
+  if (/(?:^|\s)"?--type(?:=|\s)/.test(value)) return false;
+  // Windows 命令行对含空格路径加引号包裹（"C:\...\ChatGPT.exe" args），先剥引号再比较。
+  if (value.startsWith('"')) {
+    const closing = value.indexOf('"', 1);
+    if (closing === -1) return false;
+    if (value.slice(1, closing).toLowerCase() !== executable.toLowerCase()) return false;
+    const rest = value.slice(closing + 1);
+    return rest === "" || rest.startsWith(" ");
+  }
+  const lowerValue = value.toLowerCase();
+  const lowerExecutable = executable.toLowerCase();
+  return lowerValue === lowerExecutable || lowerValue.startsWith(lowerExecutable + " ");
+}
+
+export function buildWindowsServiceCommand({ nodePath, cliPath, paths }) {
+  return [
+    "@echo off",
+    "rem MineCodex background service entry. Managed by mcx install; do not edit.",
+    'cd /d "%~dp0"',
+    `${cmdQuote(nodePath)} ${cmdQuote(cliPath)} serve >>${cmdQuote(paths.serviceLogPath)} 2>${cmdQuote(paths.serviceErrorLogPath)}`,
+    "",
+  ].join("\r\n");
+}
+
+// cmd 的引号转义是内部双引号翻倍，与 JSON 转义规则不同，不能混用。
+function cmdQuote(value) {
+  return '"' + String(value).replaceAll('"', '""') + '"';
+}
+
+export function buildWindowsServiceRuntimeConfig({ nodePath, cliPath, paths }) {
+  return JSON.stringify({
+    nodePath,
+    cliPath,
+    serviceLogPath: paths.serviceLogPath,
+    serviceErrorLogPath: paths.serviceErrorLogPath,
+  });
+}
+
 async function waitForProcessExit(pid, { processApi, timeoutMs = 8_000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)) }) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -690,3 +745,465 @@ export class MacPlatformAdapter {
     throw new Error(`LaunchServices did not expose a loopback CDP ChatGPT process on port ${cdpPort}.`);
   }
 }
+
+export class WindowsPlatformAdapter {
+  constructor({
+    platform = process.platform,
+    homeDir = os.homedir(),
+    appDataDir = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"),
+    localAppDataDir = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"),
+    execFile = defaultExecFile,
+    fileSystem = defaultFileSystem,
+    processApi = process,
+    sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    codexInstallation,
+  } = {}) {
+    this.platform = platform;
+    this.homeDir = homeDir;
+    this.appDataDir = appDataDir;
+    this.localAppDataDir = localAppDataDir;
+    this.execFile = execFile;
+    this.fileSystem = fileSystem;
+    this.processApi = processApi;
+    this.sleep = sleep;
+    this.codexInstallation = codexInstallation;
+    this.codexInstallationFingerprint = null;
+    this.codexInstallationInjected = Boolean(codexInstallation);
+  }
+
+  async powershell(script) {
+    const { stdout } = await this.execFile("powershell.exe", [
+      "-NoProfile", "-NonInteractive", "-EncodedCommand",
+      encodePowerShellCommand(POWERSHELL_PREAMBLE + "\n" + String(script)),
+    ]);
+    return String(stdout ?? "");
+  }
+
+  assertInstallSupported() {
+    if (this.platform !== "win32") {
+      throw new Error("Windows installation requires Windows 10 or newer (win32).");
+    }
+  }
+
+  async assertCodexInstalled() {
+    const script = [
+      "$pkg = Get-AppxPackage -Name 'OpenAI.Codex' -ErrorAction Stop | Select-Object -First 1;",
+      "if (-not $pkg) { throw 'Codex Desktop (OpenAI.Codex) was not found for the current user.' }",
+      "$exe = Join-Path $pkg.InstallLocation 'app\\ChatGPT.exe';",
+      "if (-not (Test-Path $exe)) { throw 'ChatGPT.exe is missing from the OpenAI.Codex package.' }",
+      "$sig = Get-AuthenticodeSignature -FilePath $exe;",
+      "[pscustomobject]@{",
+      "  installLocation = [string]$pkg.InstallLocation;",
+      "  packageFamilyName = [string]$pkg.PackageFamilyName;",
+      "  version = [string]$pkg.Version;",
+      "  exePath = $exe;",
+      "  signatureStatus = [string]$sig.Status;",
+      "  signerSubject = [string]$sig.SignerCertificate.Subject;",
+      "} | ConvertTo-Json -Compress",
+    ].join("\n");
+    const info = JSON.parse(await this.powershell(script));
+    if (info.packageFamilyName !== CODEX_WINDOWS_PACKAGE_FAMILY) {
+      throw new Error(`Refusing non-official ChatGPT package: ${info.packageFamilyName || "unknown"}`);
+    }
+    if (info.signatureStatus !== "Valid" || !/openai/i.test(info.signerSubject ?? "")) {
+      throw new Error("Refusing ChatGPT with an unexpected signing identity.");
+    }
+    this.codexInstallation = Object.freeze({
+      appPath: info.installLocation,
+      executable: info.exePath,
+      packageFamilyName: info.packageFamilyName,
+      version: info.version,
+      signerSubject: info.signerSubject,
+      verified: true,
+    });
+    this.codexInstallationFingerprint = await this.readCodexInstallationFingerprint(this.codexInstallation);
+    this.codexInstallationInjected = false;
+    return this.codexInstallation;
+  }
+
+  async codex() {
+    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, "AppxManifest.xml"),
+    ];
+    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 pathExists(filePath) {
+    try {
+      if (this.fileSystem.stat) await this.fileSystem.stat(filePath);
+      else await this.fileSystem.readFile(filePath);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+
+  async queryScheduledTaskState() {
+    const stdout = await this.powershell([
+      // Get-ScheduledTask 对不存在的任务抛 terminating error，SilentlyContinue 拦不住，必须 try/catch。
+      "try { $task = Get-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "' -ErrorAction Stop } catch { $task = $null }",
+      "if ($task) { Write-Output ([string]$task.State) } else { Write-Output 'Missing' }",
+    ].join("\n"));
+    return String(stdout).trim();
+  }
+
+  async isServiceRunning() {
+    return (await this.queryScheduledTaskState()) === "Running";
+  }
+
+  async isServiceInstalled(paths) {
+    return (await this.pathExists(paths.serviceAppPath)) || (await this.queryScheduledTaskState()) !== "Missing";
+  }
+
+  async serviceManagerStatus(paths) {
+    if (!(await this.pathExists(paths.serviceAppPath)) && (await this.queryScheduledTaskState()) === "Missing") {
+      return "not-found";
+    }
+    const state = await this.queryScheduledTaskState();
+    if (state === "Running" || state === "Ready") return "enabled";
+    if (state === "Disabled") return "disabled";
+    return "unknown";
+  }
+
+  async writeServiceRuntimeConfig(paths, content, mode = 0o600) {
+    const temporaryPath = paths.serviceRuntimeConfigPath + ".installing";
+    await this.fileSystem.writeFile(temporaryPath, content, { mode });
+    await this.fileSystem.rename(temporaryPath, paths.serviceRuntimeConfigPath);
+  }
+
+  async writeServiceCommand(paths, content) {
+    await this.fileSystem.writeFile(paths.serviceAppPath, content, { mode: 0o700 });
+  }
+
+  async snapshotServiceState(paths) {
+    const state = await this.queryScheduledTaskState();
+    const appExists = await this.pathExists(paths.serviceAppPath);
+    let runtimeConfig = { exists: false, content: null, mode: null };
+    if (appExists && paths.serviceRuntimeConfigPath) {
+      try {
+        const metadataPromise = this.fileSystem.stat
+          ? this.fileSystem.stat(paths.serviceRuntimeConfigPath).catch(() => null)
+          : Promise.resolve(null);
+        const [content, metadata] = await Promise.all([
+          this.fileSystem.readFile(paths.serviceRuntimeConfigPath, "utf8"),
+          metadataPromise,
+        ]);
+        runtimeConfig = { exists: true, content, mode: metadata?.mode };
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    let taskDefinition = { exists: false, content: null, mode: null };
+    if (state !== "Missing") {
+      try {
+        taskDefinition = { exists: true, content: await this.powershell("Export-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "'"), mode: null };
+      } catch {
+        taskDefinition = { exists: true, content: null, mode: null };
+      }
+    }
+    return {
+      app: { exists: appExists, status: appExists ? await this.serviceManagerStatus(paths) : "not-found", runtimeConfig },
+      // 字段名沿用 mac 快照契约（plist），Windows 下内容为计划任务定义。
+      plist: taskDefinition,
+      running: state === "Running",
+    };
+  }
+
+  async installService({ cliPath, paths, start = true }) {
+    await this.stopService(paths, { ignoreErrors: false });
+    await this.fileSystem.mkdir(paths.serviceDir, { recursive: true, mode: 0o700 });
+    await this.fileSystem.mkdir(paths.logsDir, { recursive: true, mode: 0o700 });
+    await this.writeServiceRuntimeConfig(paths, buildWindowsServiceRuntimeConfig({ nodePath: process.execPath, cliPath, paths }));
+    await this.writeServiceCommand(paths, buildWindowsServiceCommand({ nodePath: process.execPath, cliPath, paths }));
+    await this.registerServiceTask(paths);
+    if (start) await this.startService(paths);
+  }
+
+  async registerServiceTask(paths) {
+    // ExecutionTimeLimit 0 表示不限时：服务是常驻进程，不能被默认 72h 限制回收。
+    const script = [
+      "$serviceCmd = '" + String(paths.serviceAppPath).replaceAll("'", "''") + "';",
+      '$action = New-ScheduledTaskAction -Execute \'cmd.exe\' -Argument (\'/c ""\' + $serviceCmd + \'""\');',
+      "$trigger = New-ScheduledTaskTrigger -AtLogOn;",
+      "$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -ExecutionTimeLimit ([TimeSpan]::Zero) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1);",
+      "Register-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "' -Action $action -Trigger $trigger -Settings $settings -Force | Out-Null;",
+      "Write-Output 'registered'",
+    ].join("\n");
+    await this.powershell(script);
+  }
+
+  async startService(paths) {
+    const state = await this.queryScheduledTaskState();
+    if (state === "Missing") throw new Error("MineCodex background task is not installed. Run mcx install first.");
+    if (state === "Disabled") throw new Error("MineCodex background task is disabled. Enable it in Task Scheduler, then run mcx install again.");
+    await this.powershell("Start-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "'");
+  }
+
+  async stopService(paths, { ignoreErrors = false } = {}) {
+    try {
+      await this.powershell([
+        "try { $task = Get-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "' -ErrorAction Stop } catch { $task = $null }",
+        "if ($task) { Stop-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "' -ErrorAction Stop }",
+      ].join("\n"));
+    } catch (error) {
+      if (!ignoreErrors) throw error;
+    }
+  }
+
+  async assertServiceStopped() {
+    if (await this.isServiceRunning()) throw new Error("MineCodex scheduled task is still running.");
+  }
+
+  async restoreServiceState(snapshot, { cliPath, paths } = {}) {
+    await this.removeService(paths);
+    await this.assertServiceStopped();
+    if (snapshot?.app?.exists) {
+      await this.fileSystem.mkdir(paths.serviceDir, { recursive: true, mode: 0o700 });
+      await this.fileSystem.mkdir(paths.logsDir, { recursive: true, mode: 0o700 });
+      if (snapshot.app.runtimeConfig?.exists) {
+        await this.writeServiceRuntimeConfig(
+          paths,
+          snapshot.app.runtimeConfig.content,
+          snapshot.app.runtimeConfig.mode ? snapshot.app.runtimeConfig.mode & 0o777 : 0o600,
+        );
+      }
+      await this.writeServiceCommand(paths, buildWindowsServiceCommand({ nodePath: process.execPath, cliPath, paths }));
+      await this.registerServiceTask(paths);
+      if (snapshot.app.status === "enabled" || snapshot.running) await this.startService(paths);
+      return snapshot;
+    }
+    return snapshot;
+  }
+
+  async removeService(paths) {
+    await this.stopService(paths, { ignoreErrors: false });
+    await this.assertServiceStopped();
+    // Unregister 对不存在的任务抛 terminating error，try/catch 视为已卸载。
+    await this.powershell(
+      "try { Unregister-ScheduledTask -TaskName '" + WINDOWS_SERVICE_TASK_NAME + "' -Confirm:$false -ErrorAction Stop } catch { }",
+    );
+    if (paths?.serviceRuntimeConfigPath) {
+      await this.fileSystem.unlink(paths.serviceRuntimeConfigPath).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+      await this.fileSystem.unlink(paths.serviceRuntimeConfigPath + ".installing").catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+    }
+    await this.fileSystem.rm(paths.serviceDir, { recursive: true, force: true });
+  }
+
+  async listCodexProcesses() {
+    const installation = await this.codex();
+    const stdout = await this.powershell([
+      "$procs = Get-CimInstance Win32_Process -Filter \"Name='ChatGPT.exe'\" |",
+      "  Where-Object { $_.CommandLine } |",
+      "  ForEach-Object { [pscustomobject]@{ pid = $_.ProcessId; command = $_.CommandLine } };",
+      "ConvertTo-Json -Compress -InputObject @($procs)",
+    ].join("\n"));
+    let records;
+    try {
+      records = JSON.parse(String(stdout).trim() || "[]");
+    } catch {
+      records = [];
+    }
+    if (!Array.isArray(records)) records = [];
+    return records
+      .filter(({ command }) => isExactCodexProcessWindows(command, installation))
+      .map((processInfo) => ({
+        ...processInfo,
+        appPath: installation.appPath,
+        executable: installation.executable,
+        bundleIdentifier: installation.packageFamilyName ?? CODEX_WINDOWS_PACKAGE_FAMILY,
+        signingIdentity: installation.signerSubject ?? null,
+        verified: installation.verified !== false,
+      }));
+  }
+
+  async ownedCodexProcesses(paths) {
+    const processes = await this.listCodexProcesses();
+    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) {
+    const processes = await this.ownedCodexProcesses(paths);
+    if (processes.length) {
+      throw new Error(`MineCodex-owned Codex processes are still running: ${processes.map(({ pid }) => pid).join(", ")}`);
+    }
+  }
+
+  async snapshotNativeCodexState() {
+    const processes = (await this.listCodexProcesses()).filter(({ command }) => !command.includes("--user-data-dir="));
+    return { count: processes.length, processes };
+  }
+
+  async restoreNativeCodexState(snapshot) {
+    if (!snapshot?.count) return 0;
+    const current = (await this.listCodexProcesses()).filter(({ command }) => !command.includes("--user-data-dir="));
+    if (current.length) return current.length;
+    await this.openNativeCodex();
+    return snapshot.count;
+  }
+
+  async terminateOwnedCodex(paths) {
+    const processInfo = (await this.ownedCodexProcesses(paths))[0];
+    if (!processInfo) {
+      await this.assertOwnedCodexStopped(paths);
+      return false;
+    }
+    this.processApi.kill(processInfo.pid);
+    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(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 ownedProcessTree = await this.collectProcessTree(pid);
+    for (const treePid of ownedProcessTree) {
+      try {
+        this.processApi.kill(treePid);
+      } catch {
+        // 进程可能已自行退出，终止阶段容忍缺失。
+      }
+    }
+    await waitForProcessesExit(ownedProcessTree, { processApi: this.processApi, sleep: this.sleep });
+    return 1;
+  }
+
+  async collectProcessTree(rootPid) {
+    const stdout = await this.powershell([
+      "$procs = Get-CimInstance Win32_Process -Filter \"Name='ChatGPT.exe'\" |",
+      "  ForEach-Object { [pscustomobject]@{ pid = $_.ProcessId; ppid = $_.ParentProcessId } };",
+      "ConvertTo-Json -Compress -InputObject @($procs)",
+    ].join("\n"));
+    let records;
+    try {
+      records = JSON.parse(String(stdout).trim() || "[]");
+    } catch {
+      records = [];
+    }
+    if (!Array.isArray(records)) records = [];
+    const childrenByParent = new Map();
+    for (const { pid, ppid } of records) {
+      const children = childrenByParent.get(ppid) ?? [];
+      children.push(pid);
+      childrenByParent.set(ppid, children);
+    }
+    const descendants = [];
+    const pending = [...(childrenByParent.get(rootPid) ?? [])];
+    while (pending.length) {
+      const current = pending.shift();
+      descendants.push(current);
+      pending.push(...(childrenByParent.get(current) ?? []));
+    }
+    return [rootPid, ...descendants];
+  }
+
+  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.powershell([
+      "$owned = Get-NetTCPConnection -State Listen -LocalPort " + cdpPort + " -ErrorAction SilentlyContinue |",
+      "  Where-Object { $_.OwningProcess -eq " + processInfo.pid + " -and ($_.LocalAddress -eq '127.0.0.1' -or $_.LocalAddress -eq '::1') };",
+      "if ($owned) { Write-Output 'OWNED' } else { throw ('ChatGPT pid ' + " + processInfo.pid + " + ' does not own loopback CDP port " + cdpPort + ".') }",
+    ].join("\n"));
+    if (!String(stdout).includes("OWNED")) {
+      throw new Error(`ChatGPT pid ${processInfo.pid} does not own loopback CDP port ${cdpPort}.`);
+    }
+    return true;
+  }
+
+  async openBrowser(url) {
+    const safeUrl = String(url).replaceAll("'", "''");
+    await this.powershell("Start-Process -FilePath '" + safeUrl + "'");
+  }
+
+  async openNativeCodex({ cdpPort } = {}) {
+    const installation = await this.codex();
+    if (!Number.isInteger(cdpPort) || cdpPort <= 0 || cdpPort > 65_535) {
+      await this.powershell("Start-Process -FilePath '" + String(installation.executable).replaceAll("'", "''") + "'");
+      return null;
+    }
+    const existingPids = new Set((await this.listCodexProcesses()).map(({ pid }) => pid));
+    const safeExecutable = String(installation.executable).replaceAll("'", "''");
+    await this.powershell([
+      "Start-Process -FilePath '" + safeExecutable + "' -ArgumentList @(",
+      "  '--remote-debugging-address=127.0.0.1',",
+      "  '--remote-debugging-port=" + cdpPort + "',",
+      "  '--remote-allow-origins=http://127.0.0.1:" + cdpPort + "');",
+    ].join("\n"));
+    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(`Windows 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(`Windows did not expose a loopback CDP ChatGPT process on port ${cdpPort}.`);
+  }
+}
+
+export function createPlatformAdapter(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") return new WindowsPlatformAdapter(options);
+  return new MacPlatformAdapter(options);
+}

package/packages/cli/src/runtime-manager.mjs

@@ -190,7 +190,7 @@ export class RuntimeManager {
     const child = this.spawnProcess(process.execPath, [this.paths.runtimeEntry], {
       cwd: this.paths.packageRoot,
       env: runtimeEnvironment,
-      stdio: "inherit",
+      stdio: ["inherit", "inherit", "inherit", "ipc"],
     });
     this.child = child;
     if (hasExited(child)) {
@@ -479,7 +479,14 @@ export class RuntimeManager {
     child.once("exit", onExit);
     try {
       try {
-        child.kill(signal);
+        // Windows 的 SIGTERM 会强杀；先请求宿主清理插件子进程。
+        if (signal === "SIGTERM" && child.connected && typeof child.send === "function") {
+          child.send({ type: "minecodex:shutdown" }, (error) => {
+            if (error && !hasExited(child)) this.logger.warn?.("Runtime shutdown request failed", error.message);
+          });
+        } else {
+          child.kill(signal);
+        }
       } catch (error) {
         if (error?.code === "ESRCH") return true;
         throw error;

package/packages/runtime-host/src/codex-injection.mjs

@@ -2722,7 +2722,7 @@ export function createInjectionSource(features, {
       record.frame.contentWindow?.postMessage({
         type: "codex-personal:surface-active",
         active: Boolean(active),
-      }, record.origin);
+      }, "/");
     }
 
     function nativeSidebarTrigger() {
@@ -2749,7 +2749,7 @@ export function createInjectionSource(features, {
       record.frame.contentWindow?.postMessage({
         type: "codex-personal:sidebar-state",
         ...state,
-      }, record.origin);
+      }, "/");
     }
 
     function registerSurface(key, feature, kind, surfaceUrl, element, frame, detailId = null) {
@@ -2863,7 +2863,7 @@ export function createInjectionSource(features, {
           : tokens["--color-token-main-surface-primary"] ?? style.backgroundColor;
         record.frame.contentWindow?.postMessage(
           { type: "codex-personal:theme", theme: mode, mode, locale, tokens: surfaceTokens },
-          record.origin,
+          "/",
         );
       }
     }
@@ -2879,11 +2879,26 @@ export function createInjectionSource(features, {
       return sidebar?.getBoundingClientRect().right ?? 0;
     }
 
+    // Windows 版 Codex 在 renderer 顶部渲染横贯全宽的应用菜单条
+    // （_ApplicationMenuTopBar），page surface 必须避开该条并以内嵌卡片
+    // 形式呈现（左上圆角）。macOS 无此元素，inset 为 0，布局保持不变。
+    function applicationMenuTopInset() {
+      const menuBar = document.querySelector('[class*="_ApplicationMenuTopBar_"]');
+      if (!menuBar?.isConnected) return 0;
+      const bottom = menuBar.getBoundingClientRect().bottom;
+      return Number.isFinite(bottom) && bottom > 0 ? Math.round(bottom) : 0;
+    }
+
     function updatePageSurfacePositions() {
       const state = sidebarState();
       const left = `${state.open ? Math.max(0, sidebarRight()) : 0}px`;
+      const topInset = applicationMenuTopInset();
+      const embeddedCard = topInset > 0;
       for (const [featureId, surface] of pageSurfaces) {
         surface.style.left = left;
+        surface.style.top = `${topInset}px`;
+        surface.style.borderTopLeftRadius = embeddedCard ? "12px" : "";
+        surface.style.overflow = embeddedCard ? "hidden" : "";
         postSidebarState(surfaceRecords.get(surfaceKey(featureId, "page")), state);
       }
     }
@@ -4173,7 +4188,10 @@ export function createInjectionSource(features, {
 
     function findMessageSurface(event) {
       for (const record of surfaceRecords.values()) {
-        if (event.origin === record.origin && event.source === record.frame.contentWindow) return record;
+        // 身份以 event.source（WindowProxy 不可伪造）为准；Windows 上
+        // setDocumentContent 的 iframe 消息可能报告 null origin，
+        // 因此用已注册 frame 的 WindowProxy 精确匹配来源。
+        if (event.source === record.frame.contentWindow) return record;
       }
       return null;
     }
@@ -4186,7 +4204,7 @@ export function createInjectionSource(features, {
         ok,
         result,
         error,
-      }, record.origin);
+      }, "/");
     }
 
     function hostActionFailure(error) {
@@ -4243,8 +4261,9 @@ export function createInjectionSource(features, {
           if (!files.length || files.some((file) => !(file instanceof File))) {
             throw new Error("Real dropped File objects are required");
           }
+          // Windows 盘符路径（C:\...）不以 / 开头，需同时接受 POSIX 与 Windows 形态。
           const paths = files.map((file) => getPathForFile(file)).filter((value) => (
-            typeof value === "string" && value.startsWith("/")
+            typeof value === "string" && (/^[/\\]/.test(value) || /^[a-zA-Z]:[/\\]/.test(value))
           ));
           if (!paths.length) throw new Error("Codex could not resolve the dropped file paths");
           respondToSurface(record, requestId, { ok: true, result: { paths } });
@@ -4366,7 +4385,7 @@ export function createInjectionSource(features, {
           record.frame.contentWindow?.postMessage({
             type: "codex-personal:focus",
             feature: record.featureId,
-          }, record.origin);
+          }, "/");
         }
       }
       if (event.data.type === "codex-personal:surface-metrics" && record.kind === "pinned") {

package/packages/runtime-host/src/main.mjs

@@ -93,14 +93,22 @@ async function shutdown() {
   await featureProcesses.stop();
 }
 
+let shuttingDown = false;
+async function requestShutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    await shutdown();
+    process.exit(0);
+  } catch (error) {
+    console.error(`Runtime shutdown failed: ${error.message}`);
+    process.exit(1);
+  }
+}
 for (const signal of ["SIGINT", "SIGTERM"]) {
-  process.once(signal, async () => {
-    try {
-      await shutdown();
-      process.exit(0);
-    } catch (error) {
-      console.error(`Runtime shutdown failed: ${error.message}`);
-      process.exit(1);
-    }
-  });
+  process.once(signal, requestShutdown);
 }
+process.on("message", (message) => {
+  if (message?.type === "minecodex:shutdown") void requestShutdown();
+});
+if (process.connected) process.once("disconnect", requestShutdown);