@unlinearity/cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/companion/codex-remote-client.js

@@ -1,15 +1,22 @@
 #!/usr/bin/env node
+import crypto from "node:crypto";
 import { spawn } from "node:child_process";
+import net from "node:net";
 import path from "node:path";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, buildCodexCliArgs, resolveSpawnTarget, } from "../bridge/bridge-adapters.shared.js";
-import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
+import { killProcessTreeSync } from "../bridge/bridge-process-reaper.js";
+import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
+import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateCodexVisibleControl, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.js";
+const CODEX_VISIBLE_SWITCH_SETTLE_MS = 500;
+const CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS = 2_000;
 function log(message) {
     process.stderr.write(`[codex-remote-client] ${message}\n`);
 }
 export function parseCliArgs(argv) {
     let cwd = process.cwd();
+    let sessionStartMode;
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -19,9 +26,10 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: wechat-codex [--cwd <path>] [...codex args]",
+                "Internal Codex client usage: npm run codex:panel -- [--cwd <path>] [--session-start-mode <restore|new>] [...codex args]",
                 "",
-                'Starts the visible native Codex client and connects it to the running "wechat-bridge-codex" instance for the current directory.',
+                "Connects the visible native Codex client to the bridge runtime for the current directory.",
+                "Use --session-start-mode new to open the client without resuming the shared thread.",
                 "Unknown arguments are forwarded to the Codex client.",
                 "",
             ].join("\n"));
@@ -35,17 +43,25 @@ export function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--session-start-mode") {
+            if (next !== "restore" && next !== "new") {
+                throw new Error(`Invalid --session-start-mode value: ${next ?? "(missing)"}`);
+            }
+            sessionStartMode = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
-    return { cwd, cliArgs };
+    return { cwd, cliArgs, sessionStartMode };
 }
 export function readCodexRuntimeEndpoint(cwd) {
     const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     if (!endpoint || endpoint.kind !== "codex") {
-        throw new Error(`No active Codex bridge endpoint was found for ${cwd}. Start "wechat-bridge-codex" in that directory first.`);
+        throw new Error(`No active Codex runtime was found for ${cwd}. Run "wechat-codex" in that directory to recreate it.`);
     }
     if (endpoint.runtimeKind !== "codex_runtime_host" || (!endpoint.serverUrl && !endpoint.serverPort)) {
-        throw new Error(`The running Codex bridge for ${cwd} is using an older local companion protocol. Restart "wechat-bridge-codex" in that directory first.`);
+        throw new Error(`The running Codex runtime for ${cwd} uses an older local client protocol. Run "wechat-codex" in that directory to replace it.`);
     }
     return endpoint;
 }
@@ -55,7 +71,11 @@ export function buildRemoteCodexClientArgs(endpoint, options = {}) {
     const remoteUrl = endpoint.serverUrl ?? `ws://127.0.0.1:${endpoint.serverPort ?? endpoint.port}`;
     const args = buildCodexCliArgs(remoteUrl, {
         profile: endpoint.profile,
-        resumeThreadId: endpoint.sharedThreadId,
+        // "new" skips resume so the visible client opens a fresh Codex session
+        // instead of rejoining the shared thread.
+        resumeThreadId: options.sessionStartMode === "new"
+            ? undefined
+            : options.resumeThreadId ?? endpoint.sharedThreadId,
     });
     const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
     return [...args, "--remote-auth-token-env", tokenEnvName, ...extraCliArgs];
@@ -66,47 +86,300 @@ export function buildRemoteCodexClientEnv(endpoint, env = process.env) {
     nextEnv[tokenEnvName] = endpoint.token;
     return nextEnv;
 }
-export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
-    const spawnTarget = resolveSpawnTarget(endpoint.command, "codex");
-    const args = buildRemoteCodexClientArgs(endpoint, {
-        extraCliArgs: options.extraCliArgs,
-    });
-    const env = buildRemoteCodexClientEnv(endpoint);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(spawnTarget.file, [...spawnTarget.args, ...args], {
-            cwd: endpoint.cwd,
-            env,
+export class CodexVisibleClientSupervisor {
+    endpoint;
+    options;
+    spawnProcess;
+    stopProcessTree;
+    switchSettleMs;
+    controlToken = crypto.randomBytes(24).toString("hex");
+    childExitPromises = new WeakMap();
+    child = null;
+    currentThreadId;
+    controlServer = null;
+    controlPort = null;
+    switching = false;
+    switchChain = Promise.resolve();
+    runSettled = false;
+    resolveRun = null;
+    rejectRun = null;
+    constructor(endpoint, options = {}, dependencies = {}) {
+        this.endpoint = endpoint;
+        this.options = options;
+        this.spawnProcess = dependencies.spawnProcess ?? spawn;
+        this.stopProcessTree = dependencies.stopProcessTree ?? killProcessTreeSync;
+        this.switchSettleMs = dependencies.switchSettleMs ?? CODEX_VISIBLE_SWITCH_SETTLE_MS;
+        this.currentThreadId =
+            options.sessionStartMode === "new" ? undefined : endpoint.sharedThreadId;
+    }
+    async run() {
+        await this.startControlServer();
+        this.publishControlMetadata();
+        try {
+            return await new Promise((resolve, reject) => {
+                this.resolveRun = resolve;
+                this.rejectRun = reject;
+                try {
+                    this.spawnChild(this.currentThreadId);
+                }
+                catch (error) {
+                    this.finishRun(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        }
+        finally {
+            await this.closeControlServer();
+            updateCodexVisibleControl(this.endpoint.cwd, {
+                codexControlPort: undefined,
+                codexControlToken: undefined,
+                codexVisibleThreadId: undefined,
+            }, this.endpoint.instanceId);
+            clearLocalCompanionOccupancy(this.endpoint.cwd, this.endpoint.instanceId, {
+                adapter: "codex",
+            });
+        }
+    }
+    async switchThread(threadId) {
+        const targetThreadId = threadId.trim();
+        if (!targetThreadId) {
+            throw new Error("A Codex thread id is required.");
+        }
+        const run = this.switchChain.then(() => this.performThreadSwitch(targetThreadId));
+        this.switchChain = run.catch(() => undefined);
+        await run;
+    }
+    async performThreadSwitch(targetThreadId) {
+        if (this.runSettled) {
+            throw new Error("The visible Codex client has already stopped.");
+        }
+        const endpoint = readLocalCompanionEndpoint(this.endpoint.cwd, { adapter: "codex" });
+        const previousThreadId = endpoint?.sharedThreadId ?? this.currentThreadId;
+        const previousChild = this.child;
+        this.switching = true;
+        try {
+            if (previousChild) {
+                await this.stopChild(previousChild);
+            }
+            const nextChild = this.spawnChild(targetThreadId);
+            await this.waitForStableChild(nextChild, targetThreadId);
+            this.currentThreadId = targetThreadId;
+            this.publishControlMetadata();
+        }
+        catch (error) {
+            const switchError = error instanceof Error ? error : new Error(String(error));
+            if (previousThreadId && previousThreadId !== targetThreadId) {
+                try {
+                    const rollbackChild = this.spawnChild(previousThreadId);
+                    await this.waitForStableChild(rollbackChild, previousThreadId);
+                    this.currentThreadId = previousThreadId;
+                    this.publishControlMetadata();
+                }
+                catch (rollbackError) {
+                    throw new Error(`${switchError.message} Failed to restore the previous visible Codex thread: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, { cause: rollbackError });
+                }
+            }
+            throw switchError;
+        }
+        finally {
+            this.switching = false;
+        }
+    }
+    spawnChild(resumeThreadId) {
+        const spawnTarget = resolveSpawnTarget(this.endpoint.command, "codex");
+        const args = buildRemoteCodexClientArgs(this.endpoint, {
+            extraCliArgs: this.options.extraCliArgs,
+            sessionStartMode: resumeThreadId ? "restore" : this.options.sessionStartMode,
+            resumeThreadId,
+        });
+        const child = this.spawnProcess(spawnTarget.file, [...spawnTarget.args, ...args], {
+            cwd: this.endpoint.cwd,
+            env: buildRemoteCodexClientEnv(this.endpoint),
             stdio: "inherit",
             windowsHide: false,
         });
-        if (typeof child.pid === "number") {
-            updateLocalCompanionOccupancy(endpoint.cwd, {
-                companionPid: child.pid,
-                companionConnectedAt: new Date().toISOString(),
-            }, endpoint.instanceId, { adapter: "codex" });
-        }
-        child.once("error", (error) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
-                adapter: "codex",
-            });
-            reject(error);
+        this.child = child;
+        const exitPromise = new Promise((resolve) => {
+            let settled = false;
+            const finish = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(result);
+            };
+            child.once("error", (error) => finish({ code: null, signal: null, error }));
+            child.once("exit", (code, signal) => finish({ code, signal }));
         });
-        child.once("exit", (code, signal) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
-                adapter: "codex",
-            });
-            if (signal) {
-                process.kill(process.pid, signal);
+        this.childExitPromises.set(child, exitPromise);
+        void exitPromise.then((result) => {
+            if (this.child !== child || this.switching) {
+                return;
+            }
+            this.child = null;
+            if (result.error) {
+                this.finishRun(result.error);
                 return;
             }
-            resolve(code ?? 0);
+            this.finishRun(undefined, result.code ?? (result.signal ? 1 : 0));
         });
-    });
+        return child;
+    }
+    async stopChild(child) {
+        if (this.child === child) {
+            this.child = null;
+        }
+        try {
+            if (typeof child.pid === "number") {
+                this.stopProcessTree(child.pid);
+            }
+            else {
+                child.kill();
+            }
+        }
+        catch {
+            // The child may have already exited between the switch request and cleanup.
+        }
+        const exitPromise = this.childExitPromises.get(child);
+        if (!exitPromise) {
+            return;
+        }
+        await Promise.race([
+            exitPromise.then(() => undefined),
+            new Promise((resolve) => {
+                const timer = setTimeout(resolve, CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    async waitForStableChild(child, threadId) {
+        const exitPromise = this.childExitPromises.get(child);
+        const result = await Promise.race([
+            new Promise((resolve) => {
+                const timer = setTimeout(() => resolve(null), this.switchSettleMs);
+                timer.unref?.();
+            }),
+            exitPromise?.then((exit) => exit) ?? Promise.resolve({
+                code: null,
+                signal: null,
+                error: new Error("The visible Codex process did not expose an exit state."),
+            }),
+        ]);
+        if (result === null) {
+            return;
+        }
+        if (this.child === child) {
+            this.child = null;
+        }
+        const detail = result.error
+            ? result.error.message
+            : result.signal
+                ? `signal ${result.signal}`
+                : `code ${result.code ?? "unknown"}`;
+        throw new Error(`The visible Codex client exited while opening ${threadId} (${detail}).`);
+    }
+    async startControlServer() {
+        const server = net.createServer((socket) => {
+            let buffer = "";
+            socket.setEncoding("utf8");
+            socket.setTimeout(20_000);
+            socket.on("data", (chunk) => {
+                buffer += chunk;
+                if (buffer.length > 65_536) {
+                    socket.destroy();
+                    return;
+                }
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    socket.destroy();
+                    return;
+                }
+                const request = parseCodexVisibleSwitchRequest(parsed);
+                if (!request || request.token !== this.controlToken) {
+                    socket.destroy();
+                    return;
+                }
+                void this.switchThread(request.threadId).then(() => {
+                    sendCodexVisibleSwitchResponse(socket, {
+                        type: "switch_thread_result",
+                        id: request.id,
+                        ok: true,
+                        threadId: request.threadId,
+                    });
+                }, (error) => {
+                    sendCodexVisibleSwitchResponse(socket, {
+                        type: "switch_thread_result",
+                        id: request.id,
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            });
+            socket.once("timeout", () => socket.destroy());
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, CODEX_VISIBLE_CONTROL_HOST, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            server.close();
+            throw new Error("Could not create the visible Codex control endpoint.");
+        }
+        this.controlServer = server;
+        this.controlPort = address.port;
+    }
+    async closeControlServer() {
+        const server = this.controlServer;
+        this.controlServer = null;
+        this.controlPort = null;
+        if (!server) {
+            return;
+        }
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+    publishControlMetadata() {
+        updateLocalCompanionOccupancy(this.endpoint.cwd, {
+            companionPid: process.pid,
+            companionConnectedAt: new Date().toISOString(),
+        }, this.endpoint.instanceId, { adapter: "codex" });
+        updateCodexVisibleControl(this.endpoint.cwd, {
+            codexControlPort: this.controlPort ?? undefined,
+            codexControlToken: this.controlToken,
+            codexVisibleThreadId: this.currentThreadId,
+        }, this.endpoint.instanceId);
+    }
+    finishRun(error, exitCode = 0) {
+        if (this.runSettled) {
+            return;
+        }
+        this.runSettled = true;
+        if (error) {
+            this.rejectRun?.(error);
+        }
+        else {
+            this.resolveRun?.(exitCode);
+        }
+    }
+}
+export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
+    return await new CodexVisibleClientSupervisor(endpoint, options).run();
 }
 export async function runCodexRemoteClient(options) {
     const endpoint = readCodexRuntimeEndpoint(options.cwd);
     return await runCodexRemoteClientFromEndpoint(endpoint, {
         extraCliArgs: options.cliArgs,
+        sessionStartMode: options.sessionStartMode,
     });
 }
 async function main() {

package/dist/companion/codex-visible-client-link.js

@@ -0,0 +1,122 @@
+import crypto from "node:crypto";
+import net from "node:net";
+import { readLocalCompanionEndpoint, } from "./local-companion-link.js";
+export const CODEX_VISIBLE_CONTROL_HOST = "127.0.0.1";
+export const CODEX_VISIBLE_SWITCH_TIMEOUT_MS = 15_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function parseCodexVisibleSwitchRequest(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.type !== "switch_thread" ||
+        typeof value.id !== "string" ||
+        typeof value.token !== "string" ||
+        typeof value.threadId !== "string") {
+        return null;
+    }
+    return {
+        type: "switch_thread",
+        id: value.id,
+        token: value.token,
+        threadId: value.threadId,
+    };
+}
+export function sendCodexVisibleSwitchResponse(socket, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return;
+    }
+    socket.end(`${JSON.stringify(response)}\n`);
+}
+function resolveCodexControlEndpoint(cwd, instanceId) {
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
+    if (!endpoint || endpoint.kind !== "codex" || endpoint.instanceId !== instanceId) {
+        throw new Error(`The visible Codex client for ${cwd} is no longer attached to this runtime.`);
+    }
+    if (!endpoint.codexControlPort || !endpoint.codexControlToken) {
+        throw new Error('The visible Codex client does not support remote thread switching. Close it and run "wechat-codex" again.');
+    }
+    return endpoint;
+}
+export async function requestCodexVisibleThreadSwitch(params) {
+    const endpoint = resolveCodexControlEndpoint(params.cwd, params.instanceId);
+    const requestId = crypto.randomUUID();
+    const timeoutMs = params.timeoutMs ?? CODEX_VISIBLE_SWITCH_TIMEOUT_MS;
+    return await new Promise((resolve, reject) => {
+        const socket = net.connect({
+            host: CODEX_VISIBLE_CONTROL_HOST,
+            port: endpoint.codexControlPort,
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error, threadId) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(threadId ?? params.threadId);
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => {
+            const request = {
+                type: "switch_thread",
+                id: requestId,
+                token: endpoint.codexControlToken,
+                threadId: params.threadId,
+            };
+            socket.write(`${JSON.stringify(request)}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 65_536) {
+                finish(new Error("The visible Codex client returned an oversized control response."));
+                return;
+            }
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                finish(new Error("The visible Codex client returned an invalid control response."));
+                return;
+            }
+            if (!isRecord(parsed) || parsed.type !== "switch_thread_result" || parsed.id !== requestId) {
+                finish(new Error("The visible Codex client returned an unexpected control response."));
+                return;
+            }
+            if (parsed.ok !== true) {
+                finish(new Error(typeof parsed.error === "string"
+                    ? parsed.error
+                    : "The visible Codex client could not switch threads."));
+                return;
+            }
+            if (parsed.threadId !== params.threadId) {
+                finish(new Error(`The visible Codex client opened ${String(parsed.threadId)}, expected ${params.threadId}.`));
+                return;
+            }
+            finish(undefined, parsed.threadId);
+        });
+        socket.once("timeout", () => {
+            finish(new Error(`Timed out waiting for the visible Codex client to open ${params.threadId}.`));
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled) {
+                finish(new Error("The visible Codex client closed the control connection."));
+            }
+        });
+    });
+}

package/dist/companion/local-companion-link.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import { ensureWorkspaceChannelDir, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
+import { writeJsonFileAtomic } from "../utils/atomic-file.js";
 import { LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 function normalizeEndpoint(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -46,6 +47,9 @@ function normalizeEndpoint(value) {
         serverPort: typeof record.serverPort === "number" ? record.serverPort : undefined,
         serverUrl: typeof record.serverUrl === "string" ? record.serverUrl : undefined,
         remoteAuthTokenEnv: typeof record.remoteAuthTokenEnv === "string" ? record.remoteAuthTokenEnv : undefined,
+        codexControlPort: typeof record.codexControlPort === "number" ? record.codexControlPort : undefined,
+        codexControlToken: typeof record.codexControlToken === "string" ? record.codexControlToken : undefined,
+        codexVisibleThreadId: typeof record.codexVisibleThreadId === "string" ? record.codexVisibleThreadId : undefined,
         cwd: record.cwd,
         command: record.command,
         profile: typeof record.profile === "string" ? record.profile : undefined,
@@ -90,9 +94,13 @@ export function writeLocalCompanionEndpoint(endpoint, options = {}) {
     const payload = {
         ...serializeEndpoint(endpoint),
     };
-    fs.writeFileSync(getWorkspaceAdapterEndpointFile(endpoint.cwd, endpoint.kind), JSON.stringify(payload, null, 2), "utf8");
+    // Atomic writes: the endpoint files are rewritten on every adapter event
+    // while companions poll them concurrently; a torn write reads as JSON.parse
+    // failure → "no endpoint" → healthy bridges get restarted or duplicate
+    // clients launched.
+    writeJsonFileAtomic(getWorkspaceAdapterEndpointFile(endpoint.cwd, endpoint.kind), payload);
     if (options.writeLegacy !== false) {
-        fs.writeFileSync(endpointFile, JSON.stringify(payload, null, 2), "utf8");
+        writeJsonFileAtomic(endpointFile, payload);
     }
 }
 export function readLocalCompanionEndpoint(cwd, options = {}) {
@@ -159,6 +167,9 @@ export function clearLocalCompanionOccupancy(cwd, instanceId, options = {}) {
             companionStatus: undefined,
             companionLastStateAt: undefined,
             companionWorkerPid: undefined,
+            codexControlPort: undefined,
+            codexControlToken: undefined,
+            codexVisibleThreadId: undefined,
         });
     }
     catch {
@@ -204,6 +215,26 @@ export function updateLocalCompanionOccupancy(cwd, patch, instanceId, options =
         // Best effort cleanup.
     }
 }
+export function updateCodexVisibleControl(cwd, patch, instanceId) {
+    try {
+        const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
+        if (!endpoint || endpoint.kind !== "codex") {
+            return;
+        }
+        if (instanceId && endpoint.instanceId !== instanceId) {
+            return;
+        }
+        writeLocalCompanionEndpoint({
+            ...endpoint,
+            codexControlPort: patch.codexControlPort,
+            codexControlToken: patch.codexControlToken,
+            codexVisibleThreadId: patch.codexVisibleThreadId,
+        });
+    }
+    catch {
+        // Best effort visible Codex control metadata update.
+    }
+}
 export function sendLocalCompanionMessage(socket, message) {
     if (socket.destroyed || socket.writableEnded) {
         return false;