aiterm-mcp 0.35.1 → 0.37.0

package/dist/codex-stdio-relay.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// DesktopのJSONLと公式App ServerのUnix WebSocketの中継。RPCの内容は変更しない。
+import { createConnection } from "node:net";
+import { createInterface } from "node:readline";
+import { setTimeout as delay } from "node:timers/promises";
+import { once } from "node:events";
+import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
+import { prepareRelayDirectory } from "./codex-relay-config.js";
+export async function runCodexStdioRelay(socketPath, serverPid) {
+    let socket;
+    let ending = false;
+    let stopping;
+    function stopServer() {
+        return stopping ??= (async () => {
+            // 公式Unix受付は1回目でturn完了待ち、2回目で終了する。
+            for (let i = 0; i < 2; i++) {
+                if (process.ppid !== serverPid)
+                    return;
+                try {
+                    process.kill(serverPid, "SIGTERM");
+                }
+                catch (error) {
+                    if (error.code === "ESRCH")
+                        return;
+                    throw error;
+                }
+                if (i === 0)
+                    await delay(100);
+            }
+        })();
+    }
+    async function connectDuringStartup() {
+        const deadline = Date.now() + 15_000;
+        while (true) {
+            if (process.ppid !== serverPid)
+                throw new Error("公式App Serverが起動中に終了しました");
+            const candidate = new WebSocket("ws://localhost/rpc", {
+                createConnection: () => createConnection(socketPath), handshakeTimeout: 10_000, perMessageDeflate: false,
+            });
+            try {
+                await once(candidate, "open");
+                return candidate;
+            }
+            catch (error) {
+                candidate.on("error", () => { });
+                candidate.terminate();
+                // exec直後のsocket作成だけを待つ。送信済みRPCは再送しない。
+                if (!["ENOENT", "ECONNREFUSED"].includes(error.code ?? "") || Date.now() >= deadline)
+                    throw error;
+                await delay(25);
+            }
+        }
+    }
+    try {
+        socket = await connectDuringStartup();
+        const connected = socket;
+        connected.on("message", (data, binary) => {
+            if (binary) {
+                process.stderr.write("aiterm-relay: 予期しないバイナリ応答\n");
+                process.exitCode = 1;
+                void stopServer();
+                connected.terminate();
+                return;
+            }
+            if (!process.stdout.write(`${data.toString()}\n`))
+                connected.pause();
+        });
+        process.stdout.on("drain", () => connected.resume());
+        connected.on("error", () => {
+            process.stderr.write("aiterm-relay: 通信に失敗しました\n");
+            process.exitCode = 1;
+            void stopServer();
+        });
+        connected.on("close", () => {
+            if (!ending) {
+                process.stderr.write("aiterm-relay: 公式App Serverとの接続が終了しました\n");
+                process.exitCode = 1;
+            }
+            process.stdin.destroy();
+        });
+        process.stdout.on("error", () => { ending = true; void stopServer(); connected.terminate(); process.stdin.destroy(); });
+        const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+        for await (const line of lines) {
+            await new Promise((resolve, reject) => connected.send(line, error => error ? reject(error) : resolve()));
+        }
+        ending = true;
+        await stopServer();
+        connected.terminate();
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-relay: 中継失敗: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        await stopServer();
+        socket?.terminate();
+        process.stdin.destroy();
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const [socket, pid] = process.argv.slice(2);
+    if (socket === "--prepare") {
+        try {
+            if (process.platform === "win32")
+                throw new Error("WindowsのAF_UNIX中継は未対応です");
+            if (!pid || Buffer.byteLength(`${pid}/9999999999.sock`) >= 104)
+                throw new Error("socketのpathが長すぎます");
+            prepareRelayDirectory(pid);
+        }
+        catch (error) {
+            process.stderr.write(`aiterm-relay: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 2;
+        }
+    }
+    else if (!socket || !/^\d+$/.test(pid ?? "") || Number(pid) <= 1 || Number(pid) !== process.ppid) {
+        process.stderr.write("aiterm-relay: 親processの指定が不正です\n");
+        process.exitCode = 2;
+    }
+    else
+        await runCodexStdioRelay(socket, Number(pid));
+}

package/dist/parent-delivery.js

@@ -235,7 +235,7 @@ export class ParentDeliveryManager {
             }
             record.state = "ready";
             this.save(job);
-            // 次の依頼へ進める時点は本文保存まで。親のキュー受付を待たせない。
+            // 次の依頼へ進める時点は本文保存まで。親の受付を待たせない。
             job.delivery = this.deliver(job).catch((error) => this.reportServiceError(error));
         })();
         return job.capture;
@@ -368,7 +368,7 @@ export class ParentDeliveryManager {
                 this.jobs.set(record.delivery_id, job);
                 if (record.state === "sending") {
                     record.state = "unknown";
-                    record.error = "PARENT_DELIVERY_INTERRUPTED: キュー送信中にMCP processが終了しました。自動再送はしていません";
+                    record.error = "PARENT_DELIVERY_INTERRUPTED: 回答送信中にMCP processが終了しました。自動再送はしていません";
                     this.finish(job);
                 }
                 else if (record.state === "waiting" || record.state === "ready") {

package/dist/process-runtime.js

@@ -44,7 +44,7 @@ export function readRuntimeProcesses() {
         "$ErrorActionPreference='Stop'",
         "[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false)",
         "@(Get-CimInstance Win32_Process | Where-Object { $null -ne $_.CreationDate -and $null -ne $_.CommandLine } | ForEach-Object {",
-        "[ordered]@{ pid=[int]$_.ProcessId; parent_pid=[int]$_.ParentProcessId; started_identity=$_.CreationDate.ToUniversalTime().ToString('o'); command=$_.CommandLine; cpu_seconds=([double]$_.KernelModeTime+[double]$_.UserModeTime)/10000000 }",
+        "[ordered]@{ pid=[int]$_.ProcessId; parent_pid=[int]$_.ParentProcessId; executable=[string]$_.ExecutablePath; started_identity=$_.CreationDate.ToUniversalTime().ToString('o'); command=$_.CommandLine; cpu_seconds=([double]$_.KernelModeTime+[double]$_.UserModeTime)/10000000 }",
         "}) | ConvertTo-Json -Compress",
     ].join("\n");
     const result = spawnSync(resolveWindowsPowerShell7(), ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")], {
@@ -69,6 +69,7 @@ export function readRuntimeProcesses() {
         const command = row.command.trim();
         return {
             pid: row.pid, parent_pid: row.parent_pid, process_group_id: null, stopped: null,
+            executable: row.executable,
             started_identity: new Date(row.started_identity).toISOString(),
             command, cpu_seconds: row.cpu_seconds, argv_digest: createHash("sha256").update(command).digest("hex"),
         };

package/dist/runtime-error-store.js

@@ -7,7 +7,7 @@ import { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, expectedHostProfil
 export { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, windowsPrivateDaclVerifyCommand } from "./runtime-error-os.js";
 import { fileURLToPath } from "node:url";
 const pkg = createRequire(import.meta.url)("../package.json");
-const STORE_SCHEMA = "aiterm-mcp.runtime-errors.v1";
+const STORE_SCHEMA = "aiterm-mcp.runtime-errors.v2";
 const STATE_SCHEMA = "1.0";
 const MAX_CONFIG_BYTES = 16 * 1024;
 const MAX_STORE_BYTES = 1024 * 1024;
@@ -241,9 +241,17 @@ export class RuntimeErrorStore {
                 return EMPTY_STATE();
             throw error;
         }
-        const state = validateState(JSON.parse(text), this.maxRecords);
+        const value = JSON.parse(text);
+        const legacy = isObject(value) && value.schema_version === "aiterm-mcp.runtime-errors.v1";
+        const state = validateState(legacy ? { ...value, schema_version: STORE_SCHEMA } : value, this.maxRecords);
         if (!state)
             throw new Error("runtime error store schema が不正です");
+        // 旧集約は初回版だけを保持した。複数回発生した記録の最終発生版は復元できない。
+        if (legacy)
+            for (const record of state.records) {
+                if (record.occurrence_count > 1)
+                    record.product_version = "unknown";
+            }
         return state;
     }
     applyWindowsDacl(target, kind) {
@@ -542,6 +550,7 @@ export class RuntimeErrorStore {
             const seen = this.now().toISOString();
             const sequence = state.cursor + 1;
             if (record) {
+                record.product_version = this.productVersion;
                 record.occurrence_count += 1;
                 record.last_seen = seen;
                 record.status = "open";

package/dist/setup-cli.js

@@ -3,6 +3,9 @@ import { runSetup } from "./setup.js";
 import { removeClaudeParentHooks } from "./setup-integrations.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { configureCodexSteer } from "./setup-codex-relay.js";
+import { readRelayConfig } from "./codex-relay-config.js";
 const args = process.argv.slice(2);
 if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
     try {
@@ -15,14 +18,42 @@ if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
     }
 }
 else if (args.length === 1 && ["--help", "-h"].includes(args[0])) {
-    process.stdout.write("使い方: aiterm-setup [--json | --remove-claude-parent-hooks]\n製品の依存準備、検出したAIへの登録、MCPと端末の実動作確認を行います。結果はJSONで返します。旧版へ戻す前の専用hook解除も、この入口で行います。\n");
-}
-else if (args.length > 1 || (args.length === 1 && args[0] !== "--json")) {
-    process.stderr.write("使い方: aiterm-setup [--json]\n");
-    process.exitCode = 2;
+    process.stdout.write("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS・Windows対応で、初回はCodexの再起動が必要です。disableは元の起動設定へ戻し、statusは実際の接続を確認します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n");
 }
 else {
-    const result = await runSetup();
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    process.exitCode = result.status === "ready" ? 0 : 2;
+    try {
+        let action;
+        let json = false;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === "--json" && !json)
+                json = true;
+            else if (args[i] === "--codex-steer" && !action && ["enable", "disable", "status"].includes(args[i + 1]))
+                action = args[++i];
+            else
+                throw new Error("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]");
+        }
+        const onlySteer = action === "disable" || action === "status";
+        if (!action && !json && process.stdin.isTTY && process.stderr.isTTY && ["darwin", "win32"].includes(process.platform)) {
+            const enabled = readRelayConfig()?.enabled ?? false;
+            const prompt = createInterface({ input: process.stdin, output: process.stderr });
+            try {
+                const answer = (await prompt.question(`導入方法: 1=Aiterm単品（公式キュー配送）、2=Codex DesktopへSteerと終了後再開を有効化 [${enabled ? "2" : "1"}]: `)).trim();
+                if (answer && !["1", "2"].includes(answer))
+                    throw new Error("導入方法は1または2で指定してください");
+                action = (answer || (enabled ? "2" : "1")) === "2" ? "enable" : "disable";
+            }
+            finally {
+                prompt.close();
+            }
+        }
+        const result = onlySteer
+            ? { schema: "aiterm.codex-steer-result.v1", ...await configureCodexSteer(action) }
+            : await runSetup({ codex_steer: action });
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        process.exitCode = ["ready", "disabled"].includes(result.status) ? 0 : result.status === "restart_required" ? 3 : 2;
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-setup: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 2;
+    }
 }

package/dist/setup-codex-relay.js

@@ -0,0 +1,187 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { tmpdir } from "node:os";
+import { spawn, spawnSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { SetupError } from "./setup-platform.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRelayConfig, relayConfigDirectory, prepareRelayDirectory } from "./codex-relay-config.js";
+import { codexRelayLauncher } from "./codex-relay-launcher.js";
+import { withCodexRelay } from "./codex-relay-client.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { installRelayLogin, removeRelayLogin } from "./codex-relay-login.js";
+import { configureWindowsCodexSteer } from "./windows-codex-setup.js";
+function command(executable, args) {
+    const result = spawnSync(executable, args, { encoding: "utf8", timeout: 15_000 });
+    if (result.error || result.status !== 0)
+        throw new SetupError("codex_steer_setup_failed", `${path.basename(executable)}を実行できません`);
+    return result.stdout.trim();
+}
+function getGui(key) {
+    const result = spawnSync("/bin/launchctl", ["getenv", key], { encoding: "utf8", timeout: 5_000 });
+    if (result.status === 1 && !result.stderr.trim())
+        return null;
+    if (result.error || result.status !== 0)
+        throw new SetupError("codex_steer_environment_unavailable", "GUIの起動設定を確認できません");
+    return result.stdout.trim() || null;
+}
+function findDesktopBinary() {
+    const search = spawnSync("/usr/bin/mdfind", ["kMDItemCFBundleIdentifier == 'com.openai.codex'"], { encoding: "utf8", timeout: 10_000 });
+    const candidates = [...new Set(["/Applications/Codex.app", "/Applications/ChatGPT.app", ...(search.status === 0 ? search.stdout.trim().split("\n") : [])])];
+    const found = candidates.filter(app => {
+        if (!app || !fs.existsSync(path.join(app, "Contents", "Resources", "codex")))
+            return false;
+        const result = spawnSync("/usr/libexec/PlistBuddy", ["-c", "Print:CFBundleIdentifier", path.join(app, "Contents", "Info.plist")], { encoding: "utf8", timeout: 5_000 });
+        return result.status === 0 && result.stdout.trim() === "com.openai.codex";
+    });
+    if (found.length !== 1)
+        throw new SetupError("codex_desktop_not_identified", "Codex Desktopのインストール先を一つに特定できません");
+    const binary = path.join(found[0], "Contents", "Resources", "codex");
+    command("/usr/bin/codesign", ["--verify", "--strict", binary]);
+    const version = command(binary, ["--version"]);
+    const match = /codex-cli (\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!match || (Number(match[1]) === 0 && Number(match[2]) < 154)) {
+        throw new SetupError("codex_version_unsupported", "SteerにはCodex CLI 0.154以上を同梱したCodex Desktopが必要です");
+    }
+    return binary;
+}
+/** 模擬HOMEで起動・initialize・終了を確認する。利用者の認証やtaskは使わない。 */
+export async function verifyRelayLauncher(launcher) {
+    const temporary = fs.mkdtempSync(path.join(tmpdir(), "aiterm-relay-setup-"));
+    fs.mkdirSync(path.join(temporary, ".codex"));
+    const child = spawn(launcher, ["-c", 'cli_auth_credentials_store="file"', "-c", 'mcp_oauth_credentials_store="file"', "app-server"], {
+        env: { ...process.env, HOME: temporary, CODEX_HOME: path.join(temporary, ".codex") }, stdio: ["pipe", "pipe", "ignore"], windowsHide: true,
+    });
+    const reader = createInterface({ input: child.stdout });
+    const exited = new Promise(resolve => child.once("close", resolve));
+    try {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new SetupError("codex_relay_probe_failed", "中継経由の公式受付を確認できません")), 20_000);
+            const fail = () => { clearTimeout(timer); reject(new SetupError("codex_relay_probe_failed", "中継経由の公式起動に失敗しました")); };
+            child.once("error", fail);
+            child.once("close", fail);
+            child.stdin.once("error", fail);
+            reader.on("line", line => {
+                try {
+                    const value = JSON.parse(line);
+                    if (value.id !== 1 || value.method)
+                        return;
+                    clearTimeout(timer);
+                    if (!value.result || value.error)
+                        fail();
+                    else
+                        resolve();
+                }
+                catch {
+                    fail();
+                }
+            });
+            child.stdin.write(JSON.stringify({ id: 1, method: "initialize", params: { clientInfo: { name: "aiterm_setup", version: "1" } } }) + "\n");
+        });
+    }
+    finally {
+        child.stdin.end();
+        const timer = setTimeout(() => child.kill("SIGKILL"), 2_000);
+        const code = await exited;
+        clearTimeout(timer);
+        reader.close();
+        fs.rmSync(temporary, { recursive: true, force: true });
+        if (code !== 0)
+            throw new SetupError("codex_relay_probe_failed", "中継の終了を確認できません");
+    }
+}
+export async function liveRelay(config) {
+    if (!fs.existsSync(config.socket_root))
+        return false;
+    const processes = readRuntimeProcesses();
+    const rows = new Map(processes.map(row => [row.pid, row]));
+    const desktopPrefix = path.join(path.dirname(path.dirname(config.binary)), "MacOS") + path.sep;
+    for (const name of fs.readdirSync(config.socket_root).filter(name => /^\d+\.sock$/.test(name))) {
+        const server = rows.get(Number(name.slice(0, -5)));
+        const desktop = server && rows.get(server.parent_pid);
+        if (!server || !(server.command === config.binary || server.command.startsWith(config.binary + " "))
+            || !desktop?.command.startsWith(desktopPrefix))
+            continue;
+        try {
+            await withCodexRelay(path.join(config.socket_root, name), async (request) => { await request("thread/loaded/list", { limit: 1 }); }, 1_000);
+            return true;
+        }
+        catch (error) {
+            // 終了済みsocketだけをreadyの証拠から外す。権限・protocolエラーはそのまま返す。
+            if (!(error instanceof CodexDeliveryError) || error.delivery_code !== "CODEX_RELAY_UNAVAILABLE")
+                throw error;
+        }
+    }
+    return false;
+}
+function writeConfig(directory, config) {
+    const temporary = path.join(directory, `${randomUUID()}.tmp`);
+    fs.writeFileSync(temporary, JSON.stringify(config, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    fs.renameSync(temporary, path.join(directory, "config.json"));
+}
+export async function configureCodexSteer(action = "status", overrides = {}) {
+    if ((overrides.platform ?? process.platform) === "win32")
+        return configureWindowsCodexSteer(action, overrides);
+    const runtime = {
+        platform: process.platform, directory: relayConfigDirectory(), socket_root: `/tmp/aiterm-codex-${process.getuid?.() ?? 0}`,
+        node: process.execPath, relay: fileURLToPath(new URL("./codex-stdio-relay.js", import.meta.url)),
+        findBinary: findDesktopBinary, getGui,
+        setGui: (key, value) => { command("/bin/launchctl", value === null ? ["unsetenv", key] : ["setenv", key, value]); },
+        persist: installRelayLogin, unpersist: removeRelayLogin,
+        verify: verifyRelayLauncher, live: liveRelay, ...overrides,
+    };
+    if (runtime.platform !== "darwin") {
+        return action === "enable" ? { status: "unsupported", reason_code: "codex_steer_platform_unsupported" } : { status: "disabled" };
+    }
+    const previous = readRelayConfig(runtime.directory);
+    if (action === "status") {
+        if (!previous?.enabled)
+            return { status: "disabled" };
+        if (runtime.getGui("CODEX_CLI_PATH") !== previous.launcher)
+            return { status: "failed", reason_code: "codex_steer_configuration_changed" };
+        return await runtime.live(previous) ? { status: "ready" } : { status: "restart_required", reason_code: "codex_restart_required" };
+    }
+    if (action === "disable") {
+        if (!previous?.enabled)
+            return { status: "disabled" };
+        if (![previous.launcher, previous.previous_cli_path].includes(runtime.getGui("CODEX_CLI_PATH")))
+            throw new SetupError("codex_steer_configuration_changed", "起動設定が他から変更されています。所有外の値は上書きしません");
+        runtime.unpersist(previous.launcher);
+        runtime.setGui("CODEX_CLI_PATH", previous.previous_cli_path);
+        if (runtime.getGui("CODEX_CLI_PATH") !== previous.previous_cli_path)
+            throw new SetupError("codex_steer_readback_failed", "元の起動設定を確認できません");
+        writeConfig(runtime.directory, { ...previous, enabled: false });
+        return { status: "restart_required", reason_code: "codex_restart_required" };
+    }
+    for (const key of ["CODEX_APP_SERVER_WS_URL", "CODEX_APP_SERVER_USE_LOCAL_DAEMON", "CODEX_APP_SERVER_FORCE_CLI"]) {
+        if (runtime.getGui(key))
+            throw new SetupError("codex_steer_configuration_conflict", `${key}が設定されています。既存の接続設定は上書きしません`);
+    }
+    const binary = runtime.findBinary();
+    const current = runtime.getGui("CODEX_CLI_PATH");
+    if (previous?.enabled && ![previous.launcher, previous.previous_cli_path].includes(current))
+        throw new SetupError("codex_steer_configuration_changed", "起動設定が他から変更されています");
+    prepareRelayDirectory(runtime.directory);
+    const launcher = path.join(runtime.directory, "codex");
+    const config = { schema: "aiterm.codex-relay.v1", enabled: true, binary, node: runtime.node,
+        launcher, socket_root: runtime.socket_root, previous_cli_path: previous?.enabled ? previous.previous_cli_path : current };
+    const candidate = path.join(runtime.directory, `codex-${randomUUID()}`);
+    fs.writeFileSync(candidate, codexRelayLauncher({ ...config, relay: runtime.relay }), { mode: 0o700, flag: "wx" });
+    try {
+        await runtime.verify(candidate);
+        fs.renameSync(candidate, launcher);
+    }
+    finally {
+        if (fs.existsSync(candidate))
+            fs.unlinkSync(candidate);
+    }
+    // 起動設定の変更前に復元値を保存する。読戻し不一致を成功扱いしない。
+    writeConfig(runtime.directory, config);
+    runtime.persist(launcher);
+    runtime.setGui("CODEX_CLI_PATH", launcher);
+    if (runtime.getGui("CODEX_CLI_PATH") !== launcher)
+        throw new SetupError("codex_steer_readback_failed", "Steerの起動設定を確認できません");
+    return await runtime.live(config) ? { status: "ready" } : { status: "restart_required", reason_code: "codex_restart_required" };
+}

package/dist/setup.js

@@ -8,6 +8,8 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import { prepareBackend, runSetupCommand, SetupError } from "./setup-platform.js";
 import { configureIntegrations } from "./setup-integrations.js";
+import { configureCodexSteer } from "./setup-codex-relay.js";
+import { readRelayConfig } from "./codex-relay-config.js";
 export function globalRegistration(run = runSetupCommand) {
     const root = run(process.platform === "win32" ? "npm.cmd" : "npm", ["root", "-g"]).trim();
     if (!isAbsolute(root) || /[\r\n]/u.test(root))
@@ -75,6 +77,18 @@ export async function runSetup(options = {}) {
         }
         else
             result.status = "ready";
+        if (result.status === "ready") {
+            stage = "codex_steer";
+            result.codex_steer = await (options.steer ?? configureCodexSteer)(options.codex_steer ?? (readRelayConfig()?.enabled ? "enable" : "status"));
+            if (["failed", "unsupported", "restart_required"].includes(result.codex_steer.status)) {
+                result.status = result.codex_steer.status;
+                result.reason_code = result.codex_steer.reason_code;
+            }
+            if (result.codex_steer.status === "restart_required")
+                progress("起動設定を保存しました。Codexを完全終了して再起動し、aiterm-setup --codex-steer statusで確認してください");
+            if (result.codex_steer.status === "unsupported")
+                progress("このOSのCodex Desktop Steerは未対応です。Aiterm単品の導入・利用は可能です");
+        }
     }
     catch (error) {
         const code = error instanceof SetupError ? error.code : `${stage}_failed`;

package/dist/windows-codex-connection.js

@@ -0,0 +1,111 @@
+// gpt-connectorのWindows実装をMIT条件で移植。実行時の外部製品依存は持たない。
+import { lstatSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+import { z } from "zod";
+import { windowsPowerShellSync, quotePowerShell } from "./windows-codex-state.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+export const windowsRelaySchema = z.object({
+    schema: z.enum(["aiterm.windows-relay.v1", "gpt-connector.windows-relay.v1"]),
+    serverPid: z.number().int().positive(), serverStarted: z.string(), binary: z.string(),
+    endpoint: z.string().regex(/^ws:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}$/),
+}).strict();
+const processSchema = z.object({ pid: z.number(), parent_pid: z.number(), command: z.string(), executable: z.string(), started: z.string() });
+export function readWindowsProcesses() {
+    return readRuntimeProcesses().map(row => ({ pid: row.pid, parent_pid: row.parent_pid, command: row.command, executable: row.executable ?? "", started: row.started_identity }));
+}
+function invalid(message) { throw new CodexDeliveryError("CODEX_RELAY_CONNECTION_INVALID", message); }
+export function readWindowsRelay(file, processes = readWindowsProcesses()) {
+    if (!isAbsolute(file) || lstatSync(file).isSymbolicLink() || !lstatSync(file).isFile())
+        invalid("WindowsのSteer接続記録が不正です。");
+    const root = dirname(file);
+    if (lstatSync(root).isSymbolicLink() || !lstatSync(root).isDirectory())
+        invalid("WindowsのSteer保存先が不正です。");
+    // 接続情報は外部入力。読む前に所有者とACLを検証し、権限を修復して成功扱いしない。
+    windowsPowerShellSync(`
+$sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+foreach ($entry in @(${quotePowerShell(root)}, ${quotePowerShell(file)}, ${quotePowerShell(join(root, "token"))})) {
+  $acl = Get-Acl -LiteralPath $entry
+  if ($acl.GetOwner([System.Security.Principal.SecurityIdentifier]).Value -notin @($sid, 'S-1-5-32-544')) { throw 'Steer保存先の所有者が一致しません' }
+  foreach ($rule in $acl.Access) {
+    $identity = $rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value
+    if ($rule.AccessControlType -eq 'Allow' -and $identity -notin @($sid, 'S-1-5-18', 'S-1-5-32-544')) { throw 'Steer保存先が他userへ公開されています' }
+  }
+}`);
+    const record = windowsRelaySchema.parse(JSON.parse(readFileSync(file, "utf8")));
+    const server = processes.find(row => row.pid === record.serverPid);
+    if (!server || Date.parse(server.started) !== Date.parse(record.serverStarted) || server.executable.toLowerCase() !== record.binary.toLowerCase()
+        || !server.command.includes(record.endpoint) || !server.command.includes(join(root, "token")))
+        invalid("Windowsの親Codex processを照合できません。");
+    return record;
+}
+export function findWindowsParentSocket(rows = readWindowsProcesses(), callerPid = process.pid, root) {
+    const parents = new Map(rows.map(row => [row.pid, row]));
+    const seen = new Set();
+    let pid = parents.get(callerPid)?.parent_pid;
+    while (pid && !seen.has(pid)) {
+        const row = parents.get(pid);
+        // 自分が起動した公式CLIの引数から接続先を取得する。MCPへの環境変数継承を前提にしない。
+        const token = row && basename(row.executable).toLowerCase() === "codex.exe"
+            ? /(?:^|\s)--ws-token-file\s+(?:"([^"]+)"|(\S+))/.exec(row.command) : null;
+        const tokenFile = token?.[1] ?? token?.[2];
+        if (tokenFile && isAbsolute(tokenFile) && basename(tokenFile) === "token") {
+            const file = join(dirname(tokenFile), "connection.json");
+            if (root) {
+                const location = relative(root, file);
+                if (isAbsolute(location) || location === ".." || location.startsWith("..\\"))
+                    invalid("親CodexはAitermのSteer起動設定を使っていません。Codexを完全再起動してください。");
+            }
+            const record = readWindowsRelay(file, rows);
+            if (record.serverPid !== pid)
+                invalid("Steer接続記録と親Codexが一致しません。");
+            return file;
+        }
+        seen.add(pid);
+        pid = row?.parent_pid;
+    }
+    invalid("親CodexのSteer接続がありません。aiterm-setup --codex-steer enableを実行し、Codexを再起動してください。");
+}
+export function windowsSocketConnection(file) {
+    const record = readWindowsRelay(file);
+    const tokenFile = join(dirname(file), "token");
+    if (lstatSync(tokenFile).isSymbolicLink() || !lstatSync(tokenFile).isFile())
+        invalid("Steer認証fileが不正です。");
+    const token = readFileSync(tokenFile, "utf8");
+    if (!/^[a-f0-9]{64}$/.test(token))
+        invalid("Steer認証情報が不正です。");
+    return { url: record.endpoint, options: { headers: { Authorization: `Bearer ${token}` } } };
+}
+/** 登録済みlauncherとDesktopの子孫にある、対応する公式接続だけを共有できる。 */
+export function windowsDesktopRelay(launcher, rows = readWindowsProcesses()) {
+    const parents = new Map(rows.map(row => [row.pid, row]));
+    for (const server of rows) {
+        if (basename(server.executable).toLowerCase() !== "codex.exe" || !server.command.includes("--ws-token-file"))
+            continue;
+        let row = parents.get(server.parent_pid);
+        let matchedLauncher = false;
+        let matchedDesktop = false;
+        const seen = new Set();
+        while (row && !seen.has(row.pid)) {
+            seen.add(row.pid);
+            if (row.executable.toLowerCase() === launcher.toLowerCase())
+                matchedLauncher = true;
+            if (/\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\(?:ChatGPT|Codex)\.exe$/i.test(row.executable)) {
+                matchedDesktop = true;
+                break;
+            }
+            row = parents.get(row.parent_pid);
+        }
+        if (!matchedLauncher || !matchedDesktop)
+            continue;
+        const token = /(?:^|\s)--ws-token-file\s+(?:"([^"]+)"|(\S+))/.exec(server.command);
+        const tokenFile = token?.[1] ?? token?.[2];
+        if (!tokenFile || !isAbsolute(tokenFile) || basename(tokenFile) !== "token")
+            continue;
+        const file = join(dirname(tokenFile), "connection.json");
+        if (readWindowsRelay(file, rows).serverPid !== server.pid)
+            invalid("Steer接続記録と親Codexが一致しません。");
+        return file;
+    }
+    return null;
+}