cli-wechat-bridge 1.0.5

package/dist/companion/local-companion.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env bun
+import net from "node:net";
+import path from "node:path";
+import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
+import { LOCAL_COMPANION_RECONNECT_GRACE_MS, } from "../bridge/bridge-adapters.shared.js";
+import { runCodexRemoteClientFromEndpoint } from "./codex-remote-client.js";
+import { attachLocalCompanionMessageListener, readLocalCompanionEndpoint, sendLocalCompanionMessage, } from "./local-companion-link.js";
+import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+export const LOCAL_COMPANION_RECONNECT_RETRY_MS = 250;
+function log(adapter, message) {
+    process.stderr.write(`[${adapter}-companion] ${message}\n`);
+}
+function parseCliArgs(argv) {
+    let adapter = null;
+    let cwd = process.cwd();
+    const cliArgs = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
+        const next = argv[i + 1];
+        if (arg === "--help" || arg === "-h") {
+            process.stdout.write([
+                "Usage: local-companion --adapter <codex|claude|opencode> [--cwd <path>] [...cli args]",
+                "",
+                'Starts the visible local companion and connects it to the matching running bridge for the current directory.',
+                "Unknown arguments are forwarded to the visible CLI client.",
+                "",
+            ].join("\n"));
+            process.exit(0);
+        }
+        if (arg === "--adapter") {
+            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+                throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
+            }
+            adapter = next;
+            i += 1;
+            continue;
+        }
+        if (arg === "--cwd") {
+            if (!next) {
+                throw new Error("--cwd requires a value");
+            }
+            cwd = path.resolve(next);
+            i += 1;
+            continue;
+        }
+        cliArgs.push(arg);
+    }
+    if (!adapter) {
+        throw new Error("Missing required --adapter <codex|claude|opencode>");
+    }
+    return { adapter, cwd, cliArgs };
+}
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function readMatchingEndpoint(options) {
+    const endpoint = readLocalCompanionEndpoint(options.cwd, {
+        adapter: options.adapter,
+    });
+    if (!endpoint || endpoint.kind !== options.adapter) {
+        throw new Error(`No active ${options.adapter} bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-${options.adapter}" in that directory first.`);
+    }
+    return endpoint;
+}
+export function shouldReconnectLocalCompanion(params) {
+    return !params.shuttingDown && !params.closeReason;
+}
+export async function runLocalCompanion(options) {
+    const initialEndpoint = readMatchingEndpoint(options);
+    if (initialEndpoint.kind === "codex" &&
+        initialEndpoint.runtimeKind === "codex_runtime_host") {
+        return await runCodexRemoteClientFromEndpoint(initialEndpoint, {
+            extraCliArgs: options.cliArgs,
+        });
+    }
+    const adapter = createBridgeAdapter({
+        kind: initialEndpoint.kind,
+        command: initialEndpoint.command,
+        cwd: initialEndpoint.cwd,
+        profile: initialEndpoint.profile,
+        initialSharedSessionId: initialEndpoint.sharedSessionId ?? initialEndpoint.sharedThreadId,
+        initialResumeConversationId: initialEndpoint.resumeConversationId,
+        initialTranscriptPath: initialEndpoint.transcriptPath,
+        renderMode: initialEndpoint.kind === "codex" ? "panel" : "companion",
+        extraCliArgs: options.cliArgs,
+    });
+    let shuttingDown = false;
+    let closeReason = null;
+    let activeSocket = null;
+    let detachListener = null;
+    let reconnectPromise = null;
+    let resolveExitCode = null;
+    const exitCodePromise = new Promise((resolve) => {
+        resolveExitCode = resolve;
+    });
+    let signalHandlersRegistered = false;
+    const detachActiveSocket = (destroy = false) => {
+        const socket = activeSocket;
+        activeSocket = null;
+        detachListener?.();
+        detachListener = null;
+        if (!socket) {
+            return;
+        }
+        socket.removeAllListeners("close");
+        socket.removeAllListeners("error");
+        if (destroy) {
+            try {
+                socket.destroy();
+            }
+            catch {
+                // Best effort cleanup.
+            }
+        }
+    };
+    const resolveExit = (code) => {
+        const resolve = resolveExitCode;
+        if (!resolve) {
+            return;
+        }
+        resolveExitCode = null;
+        resolve(code);
+    };
+    const unregisterSignalHandlers = () => {
+        if (!signalHandlersRegistered) {
+            return;
+        }
+        signalHandlersRegistered = false;
+        process.removeListener("SIGINT", handleSigint);
+        process.removeListener("SIGTERM", handleSigterm);
+        process.removeListener("SIGHUP", handleSighup);
+        if (process.platform === "win32") {
+            process.removeListener("SIGBREAK", handleSigbreak);
+        }
+    };
+    const publishState = () => {
+        if (!activeSocket) {
+            return;
+        }
+        sendLocalCompanionMessage(activeSocket, {
+            type: "state",
+            state: adapter.getState(),
+        });
+    };
+    const sendResponse = (socket, id, ok, result, error) => {
+        sendLocalCompanionMessage(socket, {
+            type: "response",
+            id,
+            ok,
+            result,
+            error,
+        });
+    };
+    const announceClosing = (reason, exitCode) => {
+        closeReason = reason;
+        if (!activeSocket) {
+            return;
+        }
+        sendLocalCompanionMessage(activeSocket, {
+            type: "closing",
+            reason,
+            exitCode,
+        });
+    };
+    const closeCompanion = async (exitCode = 0, reason = "companion_shutdown") => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        announceClosing(reason, exitCode);
+        detachActiveSocket(false);
+        try {
+            await adapter.dispose();
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        resolveExit(exitCode);
+    };
+    const handleBridgeRequest = async (socket, message) => {
+        try {
+            switch (message.payload.command) {
+                case "send_input":
+                    await adapter.sendInput(message.payload.text);
+                    sendResponse(socket, message.id, true);
+                    break;
+                case "list_resume_sessions":
+                case "list_resume_threads":
+                    sendResponse(socket, message.id, true, await adapter.listResumeSessions(message.payload.limit));
+                    break;
+                case "resume_session":
+                    await adapter.resumeSession(message.payload.sessionId);
+                    publishState();
+                    sendResponse(socket, message.id, true);
+                    break;
+                case "resume_thread":
+                    await adapter.resumeSession(message.payload.threadId);
+                    publishState();
+                    sendResponse(socket, message.id, true);
+                    break;
+                case "create_session":
+                    if (!adapter.createSession) {
+                        throw new Error(`/${adapter.getState().kind} does not support creating sessions from WeChat.`);
+                    }
+                    await adapter.createSession();
+                    publishState();
+                    sendResponse(socket, message.id, true);
+                    break;
+                case "interrupt":
+                    sendResponse(socket, message.id, true, await adapter.interrupt());
+                    break;
+                case "reset":
+                    await adapter.reset();
+                    publishState();
+                    sendResponse(socket, message.id, true);
+                    break;
+                case "resolve_approval":
+                    sendResponse(socket, message.id, true, await adapter.resolveApproval(message.payload.action));
+                    break;
+                case "dispose":
+                    sendResponse(socket, message.id, true);
+                    await closeCompanion(0, "bridge_dispose");
+                    break;
+            }
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            sendResponse(socket, message.id, false, undefined, text);
+        }
+    };
+    const connectToBridge = async (endpoint) => {
+        await new Promise((resolve, reject) => {
+            const socket = net.connect({
+                host: "127.0.0.1",
+                port: endpoint.port,
+            });
+            let settled = false;
+            let helloAcknowledged = false;
+            let localDetach = null;
+            const fail = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                localDetach?.();
+                localDetach = null;
+                try {
+                    socket.destroy();
+                }
+                catch {
+                    // Best effort cleanup.
+                }
+                reject(error);
+            };
+            socket.once("connect", () => {
+                socket.setNoDelay(true);
+                localDetach = attachLocalCompanionMessageListener(socket, (message) => {
+                    if (!helloAcknowledged) {
+                        if (message.type === "hello_ack") {
+                            helloAcknowledged = true;
+                            closeReason = null;
+                            activeSocket = socket;
+                            detachListener = localDetach;
+                            if (!settled) {
+                                settled = true;
+                                resolve();
+                            }
+                        }
+                        return;
+                    }
+                    if (message.type !== "request") {
+                        return;
+                    }
+                    void handleBridgeRequest(socket, message);
+                });
+                socket.once("close", () => {
+                    if (!settled) {
+                        fail(new Error(`The ${options.adapter} bridge closed the local companion socket before authentication.`));
+                        return;
+                    }
+                    if (activeSocket === socket) {
+                        detachActiveSocket(false);
+                        void (async () => {
+                            if (!shouldReconnectLocalCompanion({
+                                shuttingDown,
+                                closeReason,
+                            })) {
+                                return;
+                            }
+                            const reconnected = await reconnectToBridge();
+                            if (!reconnected && !shuttingDown) {
+                                await closeCompanion(1, "fatal_error");
+                            }
+                        })();
+                    }
+                });
+                socket.once("error", (error) => {
+                    if (!settled) {
+                        fail(error instanceof Error
+                            ? error
+                            : new Error(String(error)));
+                    }
+                });
+                sendLocalCompanionMessage(socket, {
+                    type: "hello",
+                    token: endpoint.token,
+                    companionPid: process.pid,
+                });
+            });
+            socket.once("error", (error) => {
+                if (!settled) {
+                    fail(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        });
+    };
+    const reconnectToBridge = async () => {
+        if (reconnectPromise) {
+            return await reconnectPromise;
+        }
+        reconnectPromise = (async () => {
+            const deadline = Date.now() + LOCAL_COMPANION_RECONNECT_GRACE_MS;
+            let lastError = "";
+            log(options.adapter, `Bridge connection dropped unexpectedly. Waiting up to ${Math.ceil(LOCAL_COMPANION_RECONNECT_GRACE_MS / 1000)}s to reconnect...`);
+            while (!shuttingDown && Date.now() < deadline) {
+                try {
+                    const nextEndpoint = readMatchingEndpoint(options);
+                    await connectToBridge(nextEndpoint);
+                    publishState();
+                    log(options.adapter, `Reconnected to bridge ${nextEndpoint.instanceId}.`);
+                    return true;
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error.message : String(error);
+                    await delay(LOCAL_COMPANION_RECONNECT_RETRY_MS);
+                }
+            }
+            if (lastError) {
+                log(options.adapter, `Bridge reconnection timed out after ${Math.ceil(LOCAL_COMPANION_RECONNECT_GRACE_MS / 1000)}s: ${lastError}`);
+            }
+            else {
+                log(options.adapter, `Bridge reconnection timed out after ${Math.ceil(LOCAL_COMPANION_RECONNECT_GRACE_MS / 1000)}s.`);
+            }
+            return false;
+        })();
+        try {
+            return await reconnectPromise;
+        }
+        finally {
+            reconnectPromise = null;
+        }
+    };
+    adapter.setEventSink((event) => {
+        if (activeSocket) {
+            sendLocalCompanionMessage(activeSocket, {
+                type: "event",
+                event,
+            });
+        }
+        publishState();
+        if (event.type === "fatal_error") {
+            void closeCompanion(1, "fatal_error");
+            return;
+        }
+        if (event.type === "status" && event.status === "stopped") {
+            void closeCompanion(0, "worker_exit");
+        }
+    });
+    const requestSignalShutdown = (signal) => {
+        log(options.adapter, `Received ${signal}. Closing local companion.`);
+        void closeCompanion(0, "signal");
+    };
+    const handleSigint = () => requestSignalShutdown("SIGINT");
+    const handleSigterm = () => requestSignalShutdown("SIGTERM");
+    const handleSighup = () => requestSignalShutdown("SIGHUP");
+    const handleSigbreak = () => requestSignalShutdown("SIGBREAK");
+    process.once("SIGINT", handleSigint);
+    process.once("SIGTERM", handleSigterm);
+    process.once("SIGHUP", handleSighup);
+    if (process.platform === "win32") {
+        process.once("SIGBREAK", handleSigbreak);
+    }
+    signalHandlersRegistered = true;
+    try {
+        await connectToBridge(initialEndpoint);
+        await adapter.start();
+        publishState();
+        log(options.adapter, `Connected to bridge ${initialEndpoint.instanceId}.`);
+        return await exitCodePromise;
+    }
+    finally {
+        unregisterSignalHandlers();
+    }
+}
+export async function main(argv = process.argv.slice(2)) {
+    migrateLegacyChannelFiles((message) => log("local", message));
+    try {
+        const options = parseCliArgs(argv);
+        const exitCode = await runLocalCompanion(options);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        const adapter = (() => {
+            try {
+                return parseCliArgs(argv).adapter;
+            }
+            catch {
+                return "local";
+            }
+        })();
+        log(adapter, error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+const isDirectRun = Boolean(import.meta.main);
+if (isDirectRun) {
+    void main();
+}

package/dist/daemon/daemon-link.js

@@ -0,0 +1,175 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import { DAEMON_ENDPOINT_FILE, ensureChannelDataDir, } from "../wechat/channel-config.js";
+export const DAEMON_PROTOCOL_VERSION = 1;
+function normalizeDaemonEndpoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.protocolVersion !== "number" ||
+        typeof record.pid !== "number" ||
+        typeof record.port !== "number" ||
+        typeof record.token !== "string" ||
+        typeof record.cwd !== "string" ||
+        typeof record.startedAt !== "string") {
+        return null;
+    }
+    return {
+        protocolVersion: record.protocolVersion,
+        pid: record.pid,
+        port: record.port,
+        token: record.token,
+        cwd: record.cwd,
+        startedAt: record.startedAt,
+    };
+}
+export function buildDaemonToken() {
+    return crypto.randomBytes(18).toString("hex");
+}
+export function writeDaemonEndpoint(endpoint) {
+    ensureChannelDataDir();
+    fs.writeFileSync(DAEMON_ENDPOINT_FILE, JSON.stringify({
+        ...endpoint,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+    }, null, 2), "utf8");
+}
+export function readDaemonEndpoint() {
+    try {
+        if (!fs.existsSync(DAEMON_ENDPOINT_FILE)) {
+            return null;
+        }
+        return normalizeDaemonEndpoint(JSON.parse(fs.readFileSync(DAEMON_ENDPOINT_FILE, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearDaemonEndpoint(pid = process.pid) {
+    try {
+        const endpoint = readDaemonEndpoint();
+        if (!endpoint || endpoint.pid === pid) {
+            fs.rmSync(DAEMON_ENDPOINT_FILE, { force: true });
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sendDaemonResponse(socket, id, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return false;
+    }
+    try {
+        return socket.write(`${JSON.stringify({ id, response })}\n`);
+    }
+    catch {
+        return false;
+    }
+}
+export function attachDaemonRequestListener(socket, onRequest) {
+    let buffer = "";
+    const onData = (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            try {
+                onRequest(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed daemon IPC frames.
+            }
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", onData);
+    return () => {
+        socket.off("data", onData);
+    };
+}
+export async function sendDaemonRequest(endpoint, payload, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    const id = crypto.randomUUID();
+    return await new Promise((resolve) => {
+        const socket = net.connect({
+            host: "127.0.0.1",
+            port: endpoint.port,
+        });
+        let buffer = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            finish({ ok: false, error: "Timed out waiting for daemon response." });
+        }, timeoutMs);
+        const finish = (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(response);
+        };
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            socket.write(`${JSON.stringify({
+                id,
+                token: endpoint.token,
+                payload,
+            })}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const frame = JSON.parse(line);
+                    if (frame.id === id) {
+                        finish(frame.response);
+                    }
+                }
+                catch {
+                    // Ignore malformed daemon IPC frames.
+                }
+            }
+        });
+        socket.once("error", () => {
+            finish({ ok: false, error: "Daemon endpoint is not reachable." });
+        });
+    });
+}
+export async function isDaemonEndpointAlive(endpoint, options = {}) {
+    if (!isPidAlive(endpoint.pid)) {
+        return false;
+    }
+    const response = await sendDaemonRequest(endpoint, { command: "status" }, options);
+    return response.ok;
+}