@unlinearity/cli-wechat-bridge 1.0.0 → 1.0.2

package/dist/companion/local-companion.js

@@ -0,0 +1,411 @@
+#!/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];
+        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);
+    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 "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/media/media-types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/create-runtime-host.js

@@ -0,0 +1,12 @@
+import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
+import { CodexPtyAdapter } from "../bridge/bridge-adapters.codex.js";
+import { LegacyAdapterRuntime } from "./legacy-adapter-runtime.js";
+export function createRuntimeHost(options) {
+    if (options.kind === "codex") {
+        return new CodexPtyAdapter({
+            ...options,
+            renderMode: options.renderMode ?? "headless",
+        });
+    }
+    return new LegacyAdapterRuntime(createBridgeAdapter(options));
+}

package/dist/runtime/legacy-adapter-runtime.js

@@ -0,0 +1,40 @@
+export class LegacyAdapterRuntime {
+    runtimeKind = "legacy_adapter";
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    setEventSink(sink) {
+        this.adapter.setEventSink(sink);
+    }
+    async start() {
+        await this.adapter.start();
+    }
+    async sendInput(text) {
+        await this.adapter.sendInput(text);
+    }
+    async listResumeSessions(limit) {
+        return await this.adapter.listResumeSessions(limit);
+    }
+    async resumeSession(sessionId) {
+        await this.adapter.resumeSession(sessionId);
+    }
+    async interrupt() {
+        return await this.adapter.interrupt();
+    }
+    async reset() {
+        await this.adapter.reset();
+    }
+    async resolveApproval(action) {
+        return await this.adapter.resolveApproval(action);
+    }
+    async submitUserInput(answers) {
+        return await this.adapter.submitUserInput(answers);
+    }
+    async dispose() {
+        await this.adapter.dispose();
+    }
+    getState() {
+        return this.adapter.getState();
+    }
+}

package/dist/runtime/runtime-types.js

@@ -0,0 +1,5 @@
+export const LOCAL_CLIENT_PROTOCOL_VERSION = 2;
+export const CODEX_REMOTE_AUTH_TOKEN_ENV = "WECHAT_BRIDGE_CODEX_REMOTE_AUTH_TOKEN";
+export function hasLocalClientEndpointProvider(runtime) {
+    return typeof runtime.getLocalClientEndpoint === "function";
+}

package/dist/utils/version-checker.js

@@ -0,0 +1,161 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { CHANNEL_DATA_DIR, ensureChannelDataDir } from "../wechat/channel-config.js";
+const UPDATE_CHECK_FILE = path.join(CHANNEL_DATA_DIR, "update-check.json");
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24小时
+/**
+ * 使用 git 命令获取远程仓库最新版本号
+ */
+export async function fetchLatestVersion() {
+    try {
+        // 尝试使用 git ls-remote 获取所有 tags
+        const tagsOutput = execSync('git ls-remote --tags origin', {
+            cwd: path.resolve(import.meta.dirname, "..", ".."),
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        if (!tagsOutput) {
+            return null;
+        }
+        // 解析 tags，找到版本号格式（如 0.1.0, 0.2.0 等）
+        const versionTags = tagsOutput
+            .split('\n')
+            .filter(line => {
+            // 匹配 refs/tags/0.5.0 格式（不是 v0.5.0）
+            return line.includes('refs/tags/') &&
+                !line.includes('^{}') &&
+                /^\w+\s+refs\/tags\/\d+\.\d+\.\d+$/.test(line);
+        })
+            .map(line => {
+            const match = line.match(/refs\/tags\/(\d+\.\d+\.\d+)$/);
+            return match ? match[1] : null;
+        })
+            .filter((v) => v !== null);
+        if (versionTags.length === 0) {
+            return null;
+        }
+        // 按版本号排序，返回最新的
+        versionTags.sort((a, b) => compareVersions(b, a));
+        return versionTags[0];
+    }
+    catch (error) {
+        // 如果 git 命令失败，静默返回 null
+        return null;
+    }
+}
+/**
+ * 从本地 package.json 读取当前版本
+ */
+export async function getCurrentVersion() {
+    const packageJsonPath = path.resolve(import.meta.dirname, "..", "..", "package.json");
+    try {
+        const content = await fs.promises.readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        return packageJson.version || "0.0.0";
+    }
+    catch (error) {
+        return "0.0.0";
+    }
+}
+/**
+ * 读取更新检查缓存
+ */
+function readUpdateCache() {
+    try {
+        if (!fs.existsSync(UPDATE_CHECK_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(UPDATE_CHECK_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * 写入更新检查缓存
+ */
+function writeUpdateCache(cache) {
+    try {
+        ensureChannelDataDir();
+        fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(cache, null, 2));
+    }
+    catch (error) {
+        // 静默失败，不影响正常使用
+    }
+}
+/**
+ * 比较两个版本号
+ * @returns 返回值 > 0 表示 version1 更新，< 0 表示 version2 更新，= 0 表示相等
+ */
+export function compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const num1 = parts1[i] || 0;
+        const num2 = parts2[i] || 0;
+        if (num1 > num2)
+            return 1;
+        if (num1 < num2)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * 检查是否有新版本可用
+ * @param forceCheck 是否强制检查（忽略缓存）
+ */
+export async function checkForUpdate(forceCheck = false) {
+    const currentVersion = await getCurrentVersion();
+    // 检查缓存
+    if (!forceCheck) {
+        const cache = readUpdateCache();
+        if (cache) {
+            const lastCheckTime = new Date(cache.lastCheck).getTime();
+            const now = Date.now();
+            // 如果缓存未过期（24小时内），且已经通知过最新版本
+            if (now - lastCheckTime < CACHE_DURATION_MS) {
+                // 如果缓存的版本与当前版本一致，说明已经通知过
+                if (cache.lastNotifiedVersion === currentVersion) {
+                    return null;
+                }
+            }
+        }
+    }
+    // 从 GitHub 获取最新版本
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+        return null;
+    }
+    // 比较版本
+    const hasUpdate = compareVersions(latestVersion, currentVersion) > 0;
+    // 更新缓存
+    writeUpdateCache({
+        lastCheck: new Date().toISOString(),
+        lastNotifiedVersion: currentVersion,
+    });
+    return {
+        current: currentVersion,
+        latest: latestVersion,
+        hasUpdate,
+    };
+}
+/**
+ * 格式化更新提示信息
+ */
+export function formatUpdateMessage(versionInfo) {
+    const { current, latest } = versionInfo;
+    return `
+[Update Available] Version ${latest} is available (current: ${current})
+
+Update instructions:
+   cd CLI-WeChat-Bridge
+   git pull
+   bun install
+   npm install -g .
+
+For more information:
+   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases
+`;
+}