aiterm-mcp 0.37.1 → 0.37.3

package/dist/windows-codex-launcher.js

@@ -0,0 +1,62 @@
+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 relay;
+  [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[] {
+          plan.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,96 @@
-// 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 { writeFileSync, rmSync, realpathSync } from "node:fs";
 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 };
+    // MSIXの仮想AppData名はnative子から見えないため、起動済みの自身の実体を渡す。
+    const relay = realpathSync.native(fileURLToPath(import.meta.url));
     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, relay, 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;
     }
 }

package/dist/windows-codex-setup.js

@@ -1,18 +1,20 @@
 // gpt-connectorのWindows実装をMIT条件で移植。実行時の外部製品依存は持たない。
 // Windows Desktop用の実行file、ユーザー環境変数、親processの接続確認を所有する。
 import { existsSync, readFileSync, writeFileSync, renameSync, readdirSync, rmSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 import { randomUUID, createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { relayConfigDirectory, readRelayConfig } from "./codex-relay-config.js";
+import { relayConfigDirectory } from "./codex-relay-config.js";
 import { SetupError } from "./setup-platform.js";
 import { verifyRelayLauncher } from "./setup-codex-relay.js";
 import { withCodexRelay } from "./codex-relay-client.js";
 import { windowsPowerShellSync, quotePowerShell } from "./windows-codex-state.js";
 import { ensurePrivateDirectory, makeFilePrivate } from "./windows-codex-state.js";
-import { readWindowsRelay, windowsDesktopRelay } from "./windows-codex-connection.js";
+import { windowsDesktopRelay } from "./windows-codex-connection.js";
+import { configureRelay } from "./codex-relay-setup.js";
+import { windowsLauncherSource } from "./windows-codex-launcher.js";
 export function findWindowsCodexCache(resources, cache) {
     // Desktopが展開した4実行fileを配布元と照合する。展開・更新はDesktop自身が所有する。
     const names = ["codex.exe", "codex-code-mode-host.exe", "codex-windows-sandbox-setup.exe", "codex-command-runner.exe"];
@@ -60,48 +62,7 @@ $result = [UIntPtr]::Zero
 [void][AitermEnvironment]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$result)
 `, 10_000);
 }
-export function windowsLauncherSource(node, relay, binary, root) {
-    return `using System;
-using System.Diagnostics;
-using System.Text;
-public static class AitermLauncher {
-  static async System.Threading.Tasks.Task Input(Process child) {
-    var input = Console.OpenStandardInput(); var output = child.StandardInput.BaseStream;
-    var buffer = new byte[8192]; int count;
-    while ((count = await input.ReadAsync(buffer, 0, buffer.Length)) > 0) {
-      await output.WriteAsync(buffer, 0, count); await output.FlushAsync();
-    }
-    child.StandardInput.Close();
-  }
-  static string Quote(string 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 static int Main(string[] args) {
-    try {
-      var arguments = new StringBuilder();
-      foreach (var value in new string[] { ${[relay, binary, root].map(value => JSON.stringify(value)).join(", ")} }) arguments.Append(Quote(value)).Append(' ');
-      foreach (var value in args) arguments.Append(Quote(value)).Append(' ');
-      var start = new ProcessStartInfo(${JSON.stringify(node)}, arguments.ToString());
-      start.UseShellExecute = false; start.CreateNoWindow = true;
-      start.RedirectStandardInput = true; start.RedirectStandardOutput = true; start.RedirectStandardError = true;
-      using (var child = Process.Start(start)) {
-        Input(child).ContinueWith(task => { if (task.IsFaulted && !child.HasExited) child.Kill(); });
-        var output = child.StandardOutput.BaseStream.CopyToAsync(Console.OpenStandardOutput());
-        var error = child.StandardError.BaseStream.CopyToAsync(Console.OpenStandardError());
-        child.WaitForExit(); System.Threading.Tasks.Task.WaitAll(output, error); return child.ExitCode;
-      }
-    } catch { Console.Error.WriteLine("aiterm-mcp: Windows中継を起動できません"); return 1; }
-  }
-}
-`;
-}
+export { windowsLauncherSource } from "./windows-codex-launcher.js";
 export function buildWindowsLauncher(directory, source) {
     const digest = createHash("sha256").update(source).digest("hex").slice(0, 16);
     const launcher = join(directory, `codex-${digest}.exe`);
@@ -113,80 +74,38 @@ export function buildWindowsLauncher(directory, source) {
         throw new SetupError("codex_launcher_compiler_unavailable", "Windows標準.NET Frameworkのコンパイラが見つかりません。");
     writeFileSync(sourceFile, source);
     makeFilePrivate(sourceFile);
-    const result = spawnSync(compiler, ["/nologo", "/target:exe", `/out:${launcher}`, sourceFile], { encoding: "utf8", windowsHide: true, timeout: 20_000 });
+    const result = spawnSync(compiler, ["/nologo", "/target:exe", "/reference:System.Runtime.Serialization.dll", `/out:${launcher}`, sourceFile], { encoding: "utf8", windowsHide: true, timeout: 20_000 });
     if (result.status !== 0)
         throw new SetupError("codex_launcher_build_failed", "Windows用のCodex起動fileを作成できません。");
     makeFilePrivate(launcher);
     return launcher;
 }
 async function live(config) {
-    const file = windowsDesktopRelay(config.launcher);
+    const file = windowsDesktopRelay(config.launcher, undefined, config.socket_root);
     if (!file)
         return false;
     await withCodexRelay(file, request => request("thread/loaded/list", { limit: 1 }));
     return true;
 }
+export function windowsCodexRuntime(overrides = {}) {
+    const directory = overrides.directory ?? relayConfigDirectory();
+    const runtime = {
+        directory, socket_root: join(directory, "sessions"), node: process.execPath,
+        relay: fileURLToPath(new URL("./windows-codex-relay.js", import.meta.url)),
+        findBinary: findWindowsCodexBinary, getGui, setGui, verify: verifyRelayLauncher, live,
+        // User環境変数はsetGuiの一操作で永続化される。
+        persist: () => { }, unpersist: () => { }, prepare: ensurePrivateDirectory, save,
+        build: async (binary) => {
+            ensurePrivateDirectory(runtime.socket_root);
+            const launcher = buildWindowsLauncher(runtime.directory, windowsLauncherSource(runtime.node, runtime.relay, binary, runtime.socket_root));
+            await runtime.verify(launcher);
+            return launcher;
+        }, ...overrides,
+    };
+    return runtime;
+}
 export async function configureWindowsCodexSteer(action, overrides = {}) {
-    const runtime = { directory: relayConfigDirectory(), node: process.execPath,
-        relay: fileURLToPath(new URL("./windows-codex-relay.js", import.meta.url)), findBinary: findWindowsCodexBinary, getGui, setGui,
-        verify: verifyRelayLauncher, live,
-        shared: async (launcher) => {
-            const file = windowsDesktopRelay(launcher);
-            if (!file)
-                return null;
-            await withCodexRelay(file, request => request("thread/loaded/list", { limit: 1 }));
-            return { binary: readWindowsRelay(file).binary, root: dirname(dirname(file)) };
-        }, ...overrides };
-    const previous = readRelayConfig(runtime.directory);
-    const current = runtime.getGui("CODEX_CLI_PATH");
-    if (action === "status") {
-        if (!previous?.enabled)
-            return { status: "disabled" };
-        if (current !== 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 (current !== previous.launcher)
-            throw new SetupError("codex_steer_configuration_changed", "変更されたCodex起動設定は上書きしません。");
-        if (previous.launcher !== previous.previous_cli_path)
-            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", "元の起動設定を確認できません。");
-        save(runtime.directory, { ...previous, enabled: false });
-        return { status: "restart_required", reason_code: "codex_restart_required" };
-    }
-    if (previous?.enabled && previous.launcher !== previous.previous_cli_path && ![previous.launcher, previous.previous_cli_path].includes(current)) {
-        throw new SetupError("codex_steer_configuration_changed", "変更されたCodex起動設定は上書きしません。");
-    }
-    if (current && (current !== previous?.launcher || previous.launcher === previous.previous_cli_path)) {
-        const shared = await runtime.shared(current);
-        if (!shared)
-            throw new SetupError("codex_steer_configuration_conflict", "別のCodex起動設定との互換接続を確認できないため変更していません。");
-        ensurePrivateDirectory(runtime.directory);
-        save(runtime.directory, { schema: "aiterm.codex-relay.v1", enabled: true, binary: shared.binary,
-            node: runtime.node, launcher: current, socket_root: shared.root, previous_cli_path: current });
-        return { status: "ready" };
-    }
-    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}が設定されているため変更していません。`);
-    }
-    ensurePrivateDirectory(runtime.directory);
-    const binary = runtime.findBinary();
-    const root = join(runtime.directory, "sessions");
-    ensurePrivateDirectory(root);
-    const launcher = buildWindowsLauncher(runtime.directory, windowsLauncherSource(runtime.node, runtime.relay, binary, root));
-    await runtime.verify(launcher);
-    const config = { schema: "aiterm.codex-relay.v1", enabled: true, binary, node: runtime.node, launcher,
-        socket_root: root, previous_cli_path: previous?.enabled && previous.launcher !== previous.previous_cli_path ? previous.previous_cli_path : current };
-    save(runtime.directory, config);
-    runtime.setGui("CODEX_CLI_PATH", launcher);
-    if (runtime.getGui("CODEX_CLI_PATH") !== launcher)
-        throw new SetupError("codex_steer_readback_failed", "WindowsのCodex起動設定を確認できません。");
-    return await runtime.live(config) ? { status: "ready" } : { status: "restart_required", reason_code: "codex_restart_required" };
+    return configureRelay(action, windowsCodexRuntime(overrides));
 }
 function save(directory, config) {
     const file = join(directory, `${randomUUID()}.tmp`);

package/docs/DESIGN.md

@@ -68,7 +68,7 @@ Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼
 宛先はCodexのMCP handshakeと各要求の`_meta.threadId`から取得する。modelが指定したIDや環境変数で代用しない。
 単品導入の`src/codex-parent-receiver.ts`は同じ`CODEX_HOME`の公式app-serverへstdioで接続し、
 `thread/read`と`thread/queue/list`で宛先を確認してから`thread/queue/add`へ本文をJSONで渡す。
-Steerを選択したmacOS Desktopでは、MCP processの祖先にある公式App Serverの本人所有socketへ接続する。
+Steerを選択したmacOS・Windows Desktopでは、MCP processの祖先にある公式App Serverの本人専用接続へ接続する。
 `thread/loaded/list`と`thread/read`で同じ親を確認し、公式`turn/start`へ一度だけ送る。
 公式の`start_or_steer_turn`が実行中なら同じturnへ追加入力し、終了後なら同じtaskの次turnを開始する。
 状態を読んでから送信方法を選ぶraceや再送は作らない。model・権限のoverrideも渡さない。
@@ -84,17 +84,23 @@ macOSのユーザーLaunchAgentはログイン時に同じ起動設定を適用
 保存した元の`CODEX_CLI_PATH`へ戻す。他から変更された設定は上書きしない。
 `status=ready`は公式binary・Desktopの直接子・同じsocketのRPC応答を確認した場合だけ返す。
 初回の設定保存後は`restart_required`であり、Desktopの完全終了・再起動を要する。
-WindowsはAitermのnative launcherからNode中継と公式Desktop CLIを起動し、通常の親子関係を保つ。
-Windows標準の.NET Frameworkでlauncherを作り、引数とstdioをそのまま中継する。
+引数の解釈、JSONL中継、設定の有効化・競合・復元は両OSで共通の処理を使う。
+Windows標準の.NET Frameworkでlauncherを作り、`CreateProcessW`の親process属性と継承handle一覧で、
+公式CLIをDesktopの直接の子、中継Nodeを公式CLIの直接の子として起動する。
+launcherは終了監視だけを担い、JSON-RPCを通さない。Windowsには同一PIDでのexecがないためPIDは変わるが、
+公式binary、起動元との直接の親子関係、通常の環境とstdioは維持する。
+MSIXの仮想AppDataはnative子へ同じ論理パスを渡しても見えない場合があるため、準備processが
+自身の`realpathSync.native`を起動計画へ返し、後続の中継Nodeはその実体を起動する。
+解決は起動時に行い、設定時の保存先で固定しない。
 公式Desktopが展開した4実行ファイルを配布元のSHA-256と照合し、AitermがCodexをコピー・再配布しない。
 公式CLIの認証付きloopback WebSocketを使い、本人専用ACLのtokenと接続記録をAitermのsessions下へ置く。
 Windowsのprocess情報はprocess-runtimeが所有し、接続はPID・開始時刻・実行ファイル・token引数で照合する。
 MCP processの祖先から親を選び、同じloaded taskへ送る。開始時刻は小数桁の表記差を正規化して比較する。
-stdio EOFで自分が起動した公式serverを停止し、接続記録を削除する。
-既存の互換launcherは公式serverからlauncherとDesktopへの祖先関係、ACL、RPCが成立した場合だけ共有する。
-対応する接続記録はaiterm.windows-relay.v1とgpt-connector.windows-relay.v1で、後者もAiterm内で解釈する。
-共有時はlauncherとprevious_cli_pathを同値で記録し、enableとdisableで所有外の起動設定を変更しない。
-接続共有は任意であり、他製品のコード・設定・コマンドはAiterm単独導入の前提にならない。
+stdio EOFで自分が起動した公式serverを停止し、接続記録を削除する。native launcherはJob Objectで
+所有するprocessだけを終了し、公式serverの終了確認後に戻る。
+両OSとも有効化前に元の起動設定を保存し、Aitermのlauncherを設定する。解除は元の値へ戻す。
+旧Windows版で既存launcherを共有した設定は読取り可能だが、次のenableでAitermのlauncherへ移行する。
+起動・配送・設定・診断は他製品のコード、設定、コマンドへ依存しない。
 LinuxのSteer選択はunsupportedとする。通常の単品導入・queue配送は全対応OSで維持する。
 
 単品導入のqueue配送は親の実行中turnを中断せず、親がidleになった後に処理される。