aiterm-mcp 0.37.0 → 0.37.2

package/dist/setup-codex-relay.js

@@ -7,12 +7,13 @@ 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 { 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";
+import { windowsCodexRuntime } from "./windows-codex-setup.js";
+import { configureRelay } from "./codex-relay-setup.js";
 function command(executable, args) {
     const result = spawnSync(executable, args, { encoding: "utf8", timeout: 15_000 });
     if (result.error || result.status !== 0)
@@ -123,65 +124,31 @@ function writeConfig(directory, config) {
 }
 export async function configureCodexSteer(action = "status", overrides = {}) {
     if ((overrides.platform ?? process.platform) === "win32")
-        return configureWindowsCodexSteer(action, overrides);
+        return configureRelay(action, windowsCodexRuntime(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,
+        verify: verifyRelayLauncher, live: liveRelay, prepare: prepareRelayDirectory, save: writeConfig,
+        build: async (binary) => {
+            const launcher = path.join(runtime.directory, "codex");
+            const candidate = path.join(runtime.directory, `codex-${randomUUID()}`);
+            fs.writeFileSync(candidate, codexRelayLauncher({ binary, node: runtime.node, relay: runtime.relay, socket_root: runtime.socket_root }), { mode: 0o700, flag: "wx" });
+            try {
+                await runtime.verify(candidate);
+                fs.renameSync(candidate, launcher);
+            }
+            finally {
+                if (fs.existsSync(candidate))
+                    fs.unlinkSync(candidate);
+            }
+            return launcher;
+        }, ...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" };
+    return configureRelay(action, runtime);
 }

package/dist/windows-codex-connection.js

@@ -76,33 +76,25 @@ export function windowsSocketConnection(file) {
         invalid("Steer認証情報が不正です。");
     return { url: record.endpoint, options: { headers: { Authorization: `Bearer ${token}` } } };
 }
-/** 登録済みlauncherとDesktopの子孫にある、対応する公式接続だけを共有できる。 */
-export function windowsDesktopRelay(launcher, rows = readWindowsProcesses()) {
+/** 公式CLIの直接の親がDesktopであり、選択したlauncherの接続先を使っていることを確認する。 */
+export function windowsDesktopRelay(launcher, rows = readWindowsProcesses(), root = join(dirname(launcher), "sessions")) {
     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)
+        const desktop = parents.get(server.parent_pid);
+        if (!desktop || !/\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\(?:ChatGPT|Codex)\.exe$/i.test(desktop.executable))
+            continue;
+        if (!rows.some(row => row.parent_pid === desktop.pid && row.executable.toLowerCase() === launcher.toLowerCase()))
             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");
+        const location = relative(root, file);
+        if (isAbsolute(location) || location === ".." || location.startsWith("..\\") || location.startsWith("../"))
+            continue;
         if (readWindowsRelay(file, rows).serverPid !== server.pid)
             invalid("Steer接続記録と親Codexが一致しません。");
         return file;

package/dist/windows-codex-launcher.js

@@ -0,0 +1,61 @@
+import { windowsNativeProcessSource } from "./windows-codex-native.js";
+// POSIXのexecに対応するWindows adapter。公式CLIを起動元の直接の子、中継を公式CLIの子として起動する。
+export function windowsLauncherSource(node, relay, binary, root) {
+    const literal = (value) => JSON.stringify(value);
+    return `using System;
+using System.Diagnostics;
+using System.Text;
+using System.IO;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+${windowsNativeProcessSource}
+[DataContract] public sealed class LaunchPlan {
+  [DataMember] public string directory;
+  [DataMember] public string endpoint;
+  [DataMember] public string[] arguments;
+}
+public static class AitermLauncher {
+  static LaunchPlan Prepare(string[] args) {
+    var arguments=new StringBuilder();
+    foreach(var value in new string[] { ${[relay, "--prepare", root].map(literal).join(", ")} }) arguments.Append(AitermNativeProcess.Quote(value)).Append(' ');
+    foreach(var value in args) arguments.Append(AitermNativeProcess.Quote(value)).Append(' ');
+    var start=new ProcessStartInfo(${literal(node)},arguments.ToString());
+    start.UseShellExecute=false; start.CreateNoWindow=true;
+    start.RedirectStandardInput=true; start.RedirectStandardOutput=true; start.RedirectStandardError=true;
+    start.StandardOutputEncoding=new UTF8Encoding(false);
+    using(var child=Process.Start(start)) {
+      child.StandardInput.Close();
+      var output=child.StandardOutput.ReadToEndAsync();
+      var error=child.StandardError.BaseStream.CopyToAsync(Console.OpenStandardError());
+      child.WaitForExit(); System.Threading.Tasks.Task.WaitAll(output,error);
+      if(child.ExitCode!=0) throw new InvalidOperationException("中継の起動準備に失敗しました");
+      using(var stream=new MemoryStream(Encoding.UTF8.GetBytes(output.Result)))
+        return (LaunchPlan)new DataContractJsonSerializer(typeof(LaunchPlan)).ReadObject(stream);
+    }
+  }
+  public static int Main(string[] args) {
+    LaunchPlan plan=null;
+    try {
+      Console.OutputEncoding=new UTF8Encoding(false);
+      plan=Prepare(args);
+      using(var lifetime=new AitermNativeProcess.Lifetime())
+      using(var server=AitermNativeProcess.Start(AitermNativeProcess.ParentId(),${literal(binary)},plan.arguments,plan.directory!=null,lifetime)) {
+        if(plan.directory==null) return server.Wait();
+        // 中継は公式CLIのjobを継承する。launcherは終了監視だけを担い、JSON-RPCを通さない。
+        using(var bridge=AitermNativeProcess.Start(server.Pid,${literal(node)},new string[] {
+          ${literal(relay)},"--serve",${literal(binary)},plan.directory,plan.endpoint,server.Pid.ToString()
+        },false,null)) {
+          int code=bridge.Wait();
+          lifetime.Dispose();
+          server.Wait();
+          return code;
+        }
+      }
+    } catch(Exception error) { Console.Error.WriteLine("aiterm-mcp: Windows起動失敗: "+error.Message); return 1; }
+    finally { if(plan!=null && plan.directory!=null && Directory.Exists(plan.directory)) Directory.Delete(plan.directory,true); }
+  }
+}
+`;
+}

package/dist/windows-codex-native.js

@@ -0,0 +1,118 @@
+// Windowsの標準process作成APIで、公式CLIの直接の親と必要なstdioだけを引き継ぐ。
+// launcherと公式CLIのPIDは異なる。Macのexecと同じPIDだとは扱わない。
+export const windowsNativeProcessSource = String.raw `
+public static class AitermNativeProcess {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct StartupInfo {
+    public int cb; public string reserved,desktop,title;
+    public int x,y,xSize,ySize,xChars,yChars,fill,flags; public short show,reservedSize;
+    public IntPtr reservedBytes,input,output,error;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct StartupInfoEx { public StartupInfo startup; public IntPtr attributes; }
+  [StructLayout(LayoutKind.Sequential)] struct ProcessInfo { public IntPtr process,thread; public int pid,tid; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct ProcessEntry {
+    public uint size,usage,pid; public UIntPtr heap; public uint module,threads,parent; public int priority; public uint flags;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=260)] public string executable;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct JobLimits {
+    public long processTime,jobTime; public uint flags; public UIntPtr minWorking,maxWorking;
+    public uint activeProcesses; public UIntPtr affinity; public uint priority,scheduling;
+  }
+  [StructLayout(LayoutKind.Sequential)] struct JobInfo {
+    public JobLimits limits; public ulong reads,writes,others,readBytes,writeBytes,otherBytes;
+    public UIntPtr processMemory,jobMemory,peakProcessMemory,peakJobMemory;
+  }
+  [DllImport("kernel32.dll",SetLastError=true)] static extern IntPtr CreateToolhelp32Snapshot(uint flags,uint pid);
+  [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern bool Process32FirstW(IntPtr snapshot,ref ProcessEntry entry);
+  [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern bool Process32NextW(IntPtr snapshot,ref ProcessEntry entry);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern IntPtr OpenProcess(uint access,bool inherit,int pid);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int kind);
+  [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern IntPtr CreateFileW(string path,uint access,uint share,IntPtr security,uint creation,uint flags,IntPtr template);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool DuplicateHandle(IntPtr source,IntPtr handle,IntPtr target,out IntPtr duplicate,uint access,bool inherit,uint options);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list,int count,int flags,ref IntPtr size);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list,uint flags,IntPtr attribute,IntPtr value,IntPtr size,IntPtr previous,IntPtr returned);
+  [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+  [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)] static extern bool CreateProcessW(string app,StringBuilder command,IntPtr processSecurity,IntPtr threadSecurity,bool inherit,uint flags,IntPtr environment,string cwd,ref StartupInfoEx startup,out ProcessInfo info);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern IntPtr CreateJobObjectW(IntPtr security,IntPtr name);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job,int kind,ref JobInfo info,uint size);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool AssignProcessToJobObject(IntPtr job,IntPtr process);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern uint ResumeThread(IntPtr thread);
+  [DllImport("kernel32.dll")] static extern bool TerminateProcess(IntPtr process,uint code);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr handle,uint time);
+  [DllImport("kernel32.dll",SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr process,out uint exitCode);
+  static void Check(bool ok) { if (!ok) throw new Win32Exception(Marshal.GetLastWin32Error()); }
+  public static int ParentId() {
+    IntPtr snapshot=CreateToolhelp32Snapshot(2,0); Check(snapshot!=new IntPtr(-1));
+    try {
+      var entry=new ProcessEntry(); entry.size=(uint)Marshal.SizeOf(entry);
+      Check(Process32FirstW(snapshot,ref entry)); int current=Process.GetCurrentProcess().Id;
+      do { if(entry.pid==current) return (int)entry.parent; } while(Process32NextW(snapshot,ref entry));
+      throw new InvalidOperationException("launcherの親processが見つかりません");
+    } finally { CloseHandle(snapshot); }
+  }
+  public static string Quote(string text) {
+    if(text.Length>0 && text.IndexOfAny(new char[] {' ','\t','\n','\v','"'})<0) return text;
+    var result=new StringBuilder().Append('"'); int slashes=0;
+    foreach(char c in text) {
+      if(c=='\\') { slashes++; continue; }
+      if(c=='"') { result.Append('\\',slashes*2+1); result.Append(c); }
+      else { result.Append('\\',slashes); result.Append(c); }
+      slashes=0;
+    }
+    result.Append('\\',slashes*2); return result.Append('"').ToString();
+  }
+  public sealed class Child : IDisposable {
+    internal IntPtr handle; public readonly int Pid;
+    internal Child(IntPtr process,int pid) { handle=process; Pid=pid; }
+    public int Wait() { WaitForSingleObject(handle,0xffffffff); uint code; Check(GetExitCodeProcess(handle,out code)); return (int)code; }
+    public void Dispose() { if(handle!=IntPtr.Zero) { CloseHandle(handle); handle=IntPtr.Zero; } }
+  }
+  public sealed class Lifetime : IDisposable {
+    internal IntPtr handle;
+    public Lifetime() {
+      handle=CreateJobObjectW(IntPtr.Zero,IntPtr.Zero); Check(handle!=IntPtr.Zero);
+      var info=new JobInfo(); info.limits.flags=0x2000;
+      try { Check(SetInformationJobObject(handle,9,ref info,(uint)Marshal.SizeOf(info))); }
+      catch { Dispose(); throw; }
+    }
+    public void Dispose() { if(handle!=IntPtr.Zero) { CloseHandle(handle); handle=IntPtr.Zero; } }
+  }
+  public static Child Start(int parentId,string binary,string[] args,bool quiet,Lifetime lifetime) {
+    IntPtr parent=IntPtr.Zero,list=IntPtr.Zero,parentValue=IntPtr.Zero,handleList=IntPtr.Zero,nul=IntPtr.Zero;
+    var remote=new IntPtr[3]; var info=new ProcessInfo(); bool initialized=false;
+    try {
+      parent=OpenProcess(0x80|0x40,false,parentId); Check(parent!=IntPtr.Zero);
+      var current=GetCurrentProcess();
+      if(quiet) { nul=CreateFileW("NUL",0xc0000000,3,IntPtr.Zero,3,0,IntPtr.Zero); Check(nul!=new IntPtr(-1)); }
+      // 指定した親へ必要な3 handleだけを一時複製し、child作成直後に親から閉じる。
+      for(int i=0;i<3;i++) Check(DuplicateHandle(current,quiet && i<2 ? nul : GetStdHandle(-10-i),parent,out remote[i],0,true,2));
+      IntPtr size=IntPtr.Zero; InitializeProcThreadAttributeList(IntPtr.Zero,2,0,ref size);
+      list=Marshal.AllocHGlobal(size); Check(InitializeProcThreadAttributeList(list,2,0,ref size)); initialized=true;
+      parentValue=Marshal.AllocHGlobal(IntPtr.Size); Marshal.WriteIntPtr(parentValue,parent);
+      Check(UpdateProcThreadAttribute(list,0,(IntPtr)0x20000,parentValue,(IntPtr)IntPtr.Size,IntPtr.Zero,IntPtr.Zero));
+      handleList=Marshal.AllocHGlobal(3*IntPtr.Size);
+      for(int i=0;i<3;i++) Marshal.WriteIntPtr(handleList,i*IntPtr.Size,remote[i]);
+      Check(UpdateProcThreadAttribute(list,0,(IntPtr)0x20002,handleList,(IntPtr)(3*IntPtr.Size),IntPtr.Zero,IntPtr.Zero));
+      var startup=new StartupInfoEx(); startup.startup.cb=Marshal.SizeOf(startup); startup.attributes=list;
+      startup.startup.flags=0x100; startup.startup.input=remote[0]; startup.startup.output=remote[1]; startup.startup.error=remote[2];
+      var command=new StringBuilder(Quote(binary)); foreach(var arg in args) command.Append(' ').Append(Quote(arg));
+      Check(CreateProcessW(binary,command,IntPtr.Zero,IntPtr.Zero,true,0x80000|0x8000000|4,IntPtr.Zero,Environment.CurrentDirectory,ref startup,out info));
+      if(lifetime!=null) Check(AssignProcessToJobObject(lifetime.handle,info.process));
+      for(int i=0;i<3;i++) { IntPtr local; Check(DuplicateHandle(parent,remote[i],current,out local,0,false,3)); CloseHandle(local); remote[i]=IntPtr.Zero; }
+      Check(ResumeThread(info.thread)!=0xffffffff);
+      var child=new Child(info.process,info.pid); info.process=IntPtr.Zero; return child;
+    } catch {
+      if(info.process!=IntPtr.Zero) TerminateProcess(info.process,1);
+      throw;
+    } finally {
+      if(nul!=IntPtr.Zero && nul!=new IntPtr(-1)) CloseHandle(nul);
+      if(info.thread!=IntPtr.Zero) CloseHandle(info.thread); if(info.process!=IntPtr.Zero) CloseHandle(info.process);
+      foreach(var handle in remote) if(handle!=IntPtr.Zero) { IntPtr local; if(DuplicateHandle(parent,handle,GetCurrentProcess(),out local,0,false,3)) CloseHandle(local); }
+      if(initialized) DeleteProcThreadAttributeList(list);
+      if(list!=IntPtr.Zero) Marshal.FreeHGlobal(list); if(parentValue!=IntPtr.Zero) Marshal.FreeHGlobal(parentValue); if(handleList!=IntPtr.Zero) Marshal.FreeHGlobal(handleList);
+      if(parent!=IntPtr.Zero) CloseHandle(parent);
+    }
+  }
+}
+`;

package/dist/windows-codex-relay.js

@@ -1,154 +1,94 @@
-// gpt-connectorのWindows実装をMIT条件で移植。実行時の外部製品依存は持たない。
-// Windowsの起動processと認証付きloopback接続を所有する。JSON-RPC本文は変更しない。
-import { spawn } from "node:child_process";
+// Windowsの認証付きloopback接続と接続情報だけを所有する。起動・stdio中継の契約は共通。
 import { createServer } from "node:net";
-import { createInterface } from "node:readline";
 import { once } from "node:events";
 import { randomBytes, randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeFileSync, rmSync } from "node:fs";
-import { setTimeout as delay } from "node:timers/promises";
 import WebSocket from "ws";
 import { ensurePrivateDirectory, makeFilePrivate } from "./windows-codex-state.js";
 import { readWindowsProcesses } from "./windows-codex-connection.js";
-export function windowsServerArguments(args) {
-    let server = false;
-    const result = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (["-c", "--config", "--enable", "--disable"].includes(arg)) {
-            result.push(arg, args[++i]);
-            continue;
-        }
-        if (/^(?:--config=|--enable=|--disable=|-c.)/.test(arg)) {
-            result.push(arg);
-            continue;
-        }
-        if (!server) {
-            if (arg !== "app-server")
-                return null;
-            server = true;
-            result.push(arg);
-            continue;
-        }
-        if (["proxy", "daemon", "start", "stop", "status", "generate-ts", "generate-json-schema", "--help", "-h", "--version", "-V"].includes(arg))
-            return null;
-        if (arg === "--stdio" || arg === "--listen=stdio://")
-            continue;
-        if (arg === "--listen") {
-            if (args[++i] !== "stdio://")
-                throw new Error("stdio以外の接続指定は変更できません");
-            continue;
-        }
-        if (arg.startsWith("--listen=") || arg.startsWith("--ws-"))
-            throw new Error("既存の接続・認証指定は変更できません");
-        result.push(arg);
-    }
-    return server ? result : null;
-}
-export async function runWindowsCodexRelay(binary, root, args) {
-    const serverArgs = windowsServerArguments(args);
-    if (!serverArgs) {
-        const child = spawn(binary, args, { stdio: "inherit", windowsHide: true });
-        return (await once(child, "close"))[0] ?? 1;
-    }
+import { codexServerArguments } from "./codex-relay-arguments.js";
+import { relayCodexStdio } from "./codex-relay-stdio.js";
+export { codexServerArguments as windowsServerArguments } from "./codex-relay-arguments.js";
+export async function prepareWindowsRelay(root, args) {
+    const serverArgs = codexServerArguments(args);
+    if (!serverArgs)
+        return { directory: null, endpoint: null, arguments: args };
     const directory = join(root, randomUUID());
     ensurePrivateDirectory(directory);
-    const file = join(directory, "connection.json");
-    const tokenFile = join(directory, "token");
-    const token = randomBytes(32).toString("hex");
-    writeFileSync(tokenFile, token, { flag: "wx" });
-    makeFilePrivate(tokenFile);
-    // OSが割り当てた空きportを使い、取得競合は公式serverの起動失敗として明示する。
-    const reservation = createServer();
-    reservation.listen(0, "127.0.0.1");
-    await once(reservation, "listening");
-    const port = reservation.address().port;
-    await new Promise((resolve, reject) => reservation.close(error => error ? reject(error) : resolve()));
-    const endpoint = `ws://127.0.0.1:${port}`;
-    const child = spawn(binary, [...serverArgs, "--listen", endpoint, "--ws-auth", "capability-token", "--ws-token-file", tokenFile], {
-        stdio: ["ignore", "ignore", "pipe"], windowsHide: true,
-    });
-    const exited = new Promise(resolve => child.once("close", () => resolve()));
-    let failed;
-    child.on("error", error => { failed = error; });
-    // WebSocketの定型起動案内だけを除き、公式CLIの診断はDesktopへそのまま返す。
-    const diagnostics = createInterface({ input: child.stderr });
-    diagnostics.on("line", line => {
-        if (!/^(?:\s*|codex app-server \(WebSockets\)| {2}(?:listening on:|readyz:|healthz:|note:).*)$/.test(line))
-            process.stderr.write(line + "\n");
-    });
-    let socket;
-    const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
-    const lines = input[Symbol.asyncIterator]();
-    let ending = false;
-    const stop = () => { ending = true; child.kill(); socket?.terminate(); input.close(); process.stdin.destroy(); };
-    input.once("close", stop);
-    process.stdout.once("error", stop);
     try {
-        const deadline = Date.now() + 15_000;
-        while (!socket) {
-            if (failed || child.exitCode !== null || child.signalCode !== null)
-                throw new Error("公式Codexの起動に失敗しました", { cause: failed });
-            const candidate = new WebSocket(endpoint, { headers: { Authorization: `Bearer ${token}` }, handshakeTimeout: 1_000 });
-            try {
-                await once(candidate, "open");
-                socket = candidate;
+        const tokenFile = join(directory, "token");
+        writeFileSync(tokenFile, randomBytes(32).toString("hex"), { flag: "wx" });
+        makeFilePrivate(tokenFile);
+        // port取得後の競合は公式serverの起動失敗として明示する。
+        const reservation = createServer();
+        reservation.listen(0, "127.0.0.1");
+        await once(reservation, "listening");
+        const port = reservation.address().port;
+        await new Promise((resolve, reject) => reservation.close(error => error ? reject(error) : resolve()));
+        const endpoint = "ws://127.0.0.1:" + port;
+        return { directory, endpoint, arguments: [...serverArgs, "--listen", endpoint, "--ws-auth", "capability-token", "--ws-token-file", tokenFile] };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}
+export async function serveWindowsRelay(binary, directory, endpoint, serverPid) {
+    if (process.ppid !== serverPid)
+        throw new Error("公式Codexの子として中継を起動してください");
+    const { readFileSync } = await import("node:fs");
+    const token = readFileSync(join(directory, "token"), "utf8");
+    try {
+        await relayCodexStdio({
+            alive: () => { try {
+                process.kill(serverPid, 0);
+                return true;
             }
             catch (error) {
-                candidate.on("error", () => { });
-                candidate.terminate();
-                if (error.code !== "ECONNREFUSED" || Date.now() >= deadline)
-                    throw error;
-                await delay(50);
-            }
-        }
-        const server = readWindowsProcesses().find(row => row.pid === child.pid);
-        if (!server)
-            throw new Error("公式Codexのprocess情報がありません");
-        const record = { schema: "aiterm.windows-relay.v1", serverPid: server.pid, serverStarted: server.started, binary, endpoint };
-        writeFileSync(file, JSON.stringify(record), { flag: "wx" });
-        makeFilePrivate(file);
-        const connected = socket;
-        connected.on("message", (data, binary) => {
-            if (binary) {
-                failed = new Error("公式Codexから予期しないバイナリ応答を受信しました");
-                stop();
-                return;
-            }
-            if (!process.stdout.write(data.toString() + "\n"))
-                connected.pause();
+                if (error.code === "ESRCH")
+                    return false;
+                throw error;
+            } },
+            socket: () => new WebSocket(endpoint, { headers: { Authorization: "Bearer " + token }, handshakeTimeout: 1_000, perMessageDeflate: false }),
+            stop: async () => {
+                // launcherが保持するprocess handleにより、このPIDは終了確認まで再利用されない。
+                try {
+                    process.kill(serverPid);
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+            },
+            connected: () => {
+                const server = readWindowsProcesses().find(row => row.pid === serverPid);
+                if (!server || server.executable.toLowerCase() !== binary.toLowerCase())
+                    throw new Error("公式Codexの起動を確認できません");
+                const record = { schema: "aiterm.windows-relay.v1", serverPid, serverStarted: server.started, binary, endpoint };
+                const file = join(directory, "connection.json");
+                writeFileSync(file, JSON.stringify(record), { flag: "wx" });
+                makeFilePrivate(file);
+            },
         });
-        process.stdout.on("drain", () => connected.resume());
-        connected.on("error", () => { failed = new Error("公式Codexとの接続に失敗しました"); stop(); });
-        connected.on("close", () => { if (!ending) {
-            failed = new Error("公式Codexとの接続が終了しました");
-            stop();
-        } });
-        // initializeが接続準備前に届いても失わないよう、iteratorを接続前から保持する。
-        for await (const line of lines)
-            await new Promise((resolve, reject) => connected.send(line, error => error ? reject(error) : resolve()));
-        if (failed)
-            throw failed;
-        return 0;
     }
     finally {
-        stop();
-        await exited;
-        diagnostics.close();
         rmSync(directory, { recursive: true, force: true });
     }
 }
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-    const [binary, root, ...args] = process.argv.slice(2);
+    const [mode, ...args] = process.argv.slice(2);
     try {
-        if (!binary || !root)
-            throw new Error("Windows中継の起動指定がありません");
-        process.exitCode = await runWindowsCodexRelay(binary, root, args);
+        if (mode === "--prepare" && args[0])
+            process.stdout.write(JSON.stringify(await prepareWindowsRelay(args[0], args.slice(1))));
+        else if (mode === "--serve" && args.length === 4 && /^[1-9][0-9]*$/.test(args[3]))
+            await serveWindowsRelay(args[0], args[1], args[2], Number(args[3]));
+        else
+            throw new Error("Windows中継の起動指定が不正です");
     }
     catch (error) {
-        process.stderr.write(`aiterm-mcp: ${error instanceof Error ? error.message : "Windows中継が失敗しました"}\n`);
+        process.stderr.write("aiterm-mcp: " + (error instanceof Error ? error.message : "Windows中継が失敗しました") + "\n");
         process.exitCode = 1;
     }
 }