cli-wechat-bridge 1.0.5

package/dist/commands/check-update.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+import { checkForUpdate, getCurrentVersion, fetchLatestVersion, compareVersions, } from "../utils/version-checker.js";
+async function main() {
+    const currentVersion = await getCurrentVersion();
+    console.log(`CLI WeChat Bridge Version Check`);
+    console.log(`Current version: v${currentVersion}\n`);
+    console.log(`Checking for updates...`);
+    const versionInfo = await checkForUpdate(true); // 强制检查
+    if (!versionInfo) {
+        console.log(`ERROR: Unable to check for updates, please check your network connection`);
+        process.exit(1);
+    }
+    if (!versionInfo.hasUpdate) {
+        console.log(`OK: Already up to date (v${versionInfo.latest})`);
+        process.exit(0);
+    }
+    console.log(`[New Version Available] v${versionInfo.latest}`);
+    console.log(`Current version: v${versionInfo.current}\n`);
+    console.log(`Update instructions:`);
+    console.log(`   cd CLI-WeChat-Bridge`);
+    console.log(`   git pull`);
+    console.log(`   bun install`);
+    console.log(`   npm install -g .\n`);
+    console.log(`For more information:`);
+    console.log(`   https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases`);
+}
+main().catch((error) => {
+    console.error(`Error checking for updates: ${error.message}`);
+    process.exit(1);
+});

package/dist/companion/codex-panel-link.js

@@ -0,0 +1,72 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { ensureWorkspaceChannelDir, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
+export function buildCodexPanelToken() {
+    return crypto.randomBytes(18).toString("hex");
+}
+export function writeCodexPanelEndpoint(endpoint) {
+    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
+    fs.writeFileSync(endpointFile, JSON.stringify(endpoint, null, 2), "utf8");
+}
+export function readCodexPanelEndpoint(cwd) {
+    try {
+        const { endpointFile } = getWorkspaceChannelPaths(cwd);
+        if (!fs.existsSync(endpointFile)) {
+            return null;
+        }
+        return JSON.parse(fs.readFileSync(endpointFile, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearCodexPanelEndpoint(cwd, instanceId) {
+    try {
+        const { endpointFile } = getWorkspaceChannelPaths(cwd);
+        if (!fs.existsSync(endpointFile)) {
+            return;
+        }
+        if (!instanceId) {
+            fs.rmSync(endpointFile, { force: true });
+            return;
+        }
+        const endpoint = readCodexPanelEndpoint(cwd);
+        if (!endpoint || endpoint.instanceId === instanceId) {
+            fs.rmSync(endpointFile, { force: true });
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function sendCodexPanelMessage(socket, message) {
+    socket.write(`${JSON.stringify(message)}\n`);
+}
+export function attachCodexPanelMessageListener(socket, onMessage) {
+    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 {
+                onMessage(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed local IPC frames.
+            }
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", onData);
+    return () => {
+        socket.off("data", onData);
+    };
+}

package/dist/companion/codex-panel.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+import net from "node:net";
+import path from "node:path";
+import { createBridgeAdapter } from "../bridge/bridge-adapters.js";
+import { attachCodexPanelMessageListener, readCodexPanelEndpoint, sendCodexPanelMessage, } from "./codex-panel-link.js";
+import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+function log(message) {
+    process.stderr.write(`[codex-panel] ${message}\n`);
+}
+function parseCliArgs(argv) {
+    let cwd = process.cwd();
+    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: wechat-codex [--cwd <path>]",
+                "",
+                'Starts the visible Codex panel and connects it to the running "wechat-bridge-codex" instance for the current directory.',
+                "",
+            ].join("\n"));
+            process.exit(0);
+        }
+        if (arg === "--cwd") {
+            if (!next) {
+                throw new Error("--cwd requires a value");
+            }
+            cwd = path.resolve(next);
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return { cwd };
+}
+async function main() {
+    migrateLegacyChannelFiles(log);
+    const options = parseCliArgs(process.argv.slice(2));
+    const endpoint = readCodexPanelEndpoint(options.cwd);
+    if (!endpoint) {
+        throw new Error(`No active Codex bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-codex" in that directory first.`);
+    }
+    const socket = await new Promise((resolve, reject) => {
+        const nextSocket = net.connect({
+            host: "127.0.0.1",
+            port: endpoint.port,
+        });
+        nextSocket.once("connect", () => resolve(nextSocket));
+        nextSocket.once("error", (error) => reject(error));
+    });
+    socket.setNoDelay(true);
+    const adapter = createBridgeAdapter({
+        kind: "codex",
+        command: endpoint.command,
+        cwd: endpoint.cwd,
+        profile: endpoint.profile,
+        initialSharedThreadId: endpoint.sharedThreadId,
+        renderMode: "panel",
+    });
+    let shuttingDown = false;
+    let helloAcknowledged = false;
+    let detachListener = null;
+    const publishState = () => {
+        sendCodexPanelMessage(socket, {
+            type: "state",
+            state: adapter.getState(),
+        });
+    };
+    const sendResponse = (id, ok, result, error) => {
+        sendCodexPanelMessage(socket, {
+            type: "response",
+            id,
+            ok,
+            result,
+            error,
+        });
+    };
+    const closePanel = async (exitCode = 0) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        detachListener?.();
+        detachListener = null;
+        try {
+            await adapter.dispose();
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        try {
+            socket.end();
+            socket.destroy();
+        }
+        catch {
+            // Best effort cleanup.
+        }
+        process.exit(exitCode);
+    };
+    adapter.setEventSink((event) => {
+        sendCodexPanelMessage(socket, {
+            type: "event",
+            event,
+        });
+        publishState();
+    });
+    detachListener = attachCodexPanelMessageListener(socket, (message) => {
+        if (!helloAcknowledged) {
+            if (message.type === "hello_ack") {
+                helloAcknowledged = true;
+            }
+            return;
+        }
+        if (message.type !== "request") {
+            return;
+        }
+        void (async () => {
+            try {
+                switch (message.payload.command) {
+                    case "send_input":
+                        await adapter.sendInput(message.payload.text);
+                        sendResponse(message.id, true);
+                        break;
+                    case "list_resume_sessions":
+                    case "list_resume_threads":
+                        sendResponse(message.id, true, await adapter.listResumeSessions(message.payload.limit));
+                        break;
+                    case "resume_session":
+                        await adapter.resumeSession(message.payload.sessionId);
+                        publishState();
+                        sendResponse(message.id, true);
+                        break;
+                    case "resume_thread":
+                        await adapter.resumeSession(message.payload.threadId);
+                        publishState();
+                        sendResponse(message.id, true);
+                        break;
+                    case "interrupt":
+                        sendResponse(message.id, true, await adapter.interrupt());
+                        break;
+                    case "reset":
+                        await adapter.reset();
+                        publishState();
+                        sendResponse(message.id, true);
+                        break;
+                    case "resolve_approval":
+                        sendResponse(message.id, true, await adapter.resolveApproval(message.payload.action));
+                        break;
+                    case "dispose":
+                        sendResponse(message.id, true);
+                        await closePanel(0);
+                        break;
+                }
+            }
+            catch (error) {
+                const text = error instanceof Error ? error.message : String(error);
+                sendResponse(message.id, false, undefined, text);
+            }
+        })();
+    });
+    socket.once("close", () => {
+        void closePanel(0);
+    });
+    socket.once("error", () => {
+        void closePanel(1);
+    });
+    sendCodexPanelMessage(socket, {
+        type: "hello",
+        token: endpoint.token,
+        panelPid: process.pid,
+    });
+    await adapter.start();
+    publishState();
+    log(`Connected to bridge ${endpoint.instanceId}.`);
+}
+main().catch((error) => {
+    log(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

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

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+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 { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.js";
+function log(message) {
+    process.stderr.write(`[codex-remote-client] ${message}\n`);
+}
+export function parseCliArgs(argv) {
+    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: wechat-codex [--cwd <path>] [...codex args]",
+                "",
+                'Starts the visible native Codex client and connects it to the running "wechat-bridge-codex" instance for the current directory.',
+                "Unknown arguments are forwarded to the Codex client.",
+                "",
+            ].join("\n"));
+            process.exit(0);
+        }
+        if (arg === "--cwd") {
+            if (!next) {
+                throw new Error("--cwd requires a value");
+            }
+            cwd = path.resolve(next);
+            i += 1;
+            continue;
+        }
+        cliArgs.push(arg);
+    }
+    return { cwd, cliArgs };
+}
+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.`);
+    }
+    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.`);
+    }
+    return endpoint;
+}
+export function buildRemoteCodexClientArgs(endpoint, options = {}) {
+    const extraCliArgs = options.extraCliArgs ?? [];
+    assertNoReservedExtraCliArgs(extraCliArgs, ["--remote", "--remote-auth-token-env"], "Codex remote connection");
+    const remoteUrl = endpoint.serverUrl ?? `ws://127.0.0.1:${endpoint.serverPort ?? endpoint.port}`;
+    const args = buildCodexCliArgs(remoteUrl, {
+        profile: endpoint.profile,
+        resumeThreadId: endpoint.sharedThreadId,
+    });
+    const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
+    return [...args, "--remote-auth-token-env", tokenEnvName, ...extraCliArgs];
+}
+export function buildRemoteCodexClientEnv(endpoint, env = process.env) {
+    const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
+    const nextEnv = buildCliEnvironment("codex", { 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,
+            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);
+        });
+        child.once("exit", (code, signal) => {
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            resolve(code ?? 0);
+        });
+    });
+}
+export async function runCodexRemoteClient(options) {
+    const endpoint = readCodexRuntimeEndpoint(options.cwd);
+    return await runCodexRemoteClientFromEndpoint(endpoint, {
+        extraCliArgs: options.cliArgs,
+    });
+}
+async function main() {
+    migrateLegacyChannelFiles(log);
+    const options = parseCliArgs(process.argv.slice(2));
+    const exitCode = await runCodexRemoteClient(options);
+    process.exit(exitCode);
+}
+const isDirectRun = Boolean(import.meta.main);
+if (isDirectRun) {
+    main().catch((error) => {
+        log(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

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

@@ -0,0 +1,240 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { ensureWorkspaceChannelDir, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";
+import { LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
+function normalizeEndpoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const kind = record.kind === "codex" || record.kind === "claude" || record.kind === "opencode" || record.kind === "shell"
+        ? record.kind
+        : "codex";
+    const sharedSessionId = typeof record.sharedSessionId === "string"
+        ? record.sharedSessionId
+        : typeof record.sharedThreadId === "string"
+            ? record.sharedThreadId
+            : undefined;
+    if (typeof record.instanceId !== "string" ||
+        typeof record.port !== "number" ||
+        typeof record.token !== "string" ||
+        typeof record.cwd !== "string" ||
+        typeof record.command !== "string" ||
+        typeof record.startedAt !== "string") {
+        return null;
+    }
+    return {
+        protocolVersion: typeof record.protocolVersion === "number"
+            ? record.protocolVersion
+            : LOCAL_CLIENT_PROTOCOL_VERSION,
+        runtimeKind: record.runtimeKind === "codex_runtime_host" ? "codex_runtime_host" : "legacy_adapter",
+        instanceId: record.instanceId,
+        kind,
+        port: record.port,
+        token: record.token,
+        renderMode: record.renderMode === "embedded" ||
+            record.renderMode === "panel" ||
+            record.renderMode === "companion" ||
+            record.renderMode === "headless"
+            ? record.renderMode
+            : undefined,
+        bridgeOwnerPid: typeof record.bridgeOwnerPid === "number" ? record.bridgeOwnerPid : undefined,
+        serverPort: typeof record.serverPort === "number" ? record.serverPort : undefined,
+        serverUrl: typeof record.serverUrl === "string" ? record.serverUrl : undefined,
+        remoteAuthTokenEnv: typeof record.remoteAuthTokenEnv === "string" ? record.remoteAuthTokenEnv : undefined,
+        cwd: record.cwd,
+        command: record.command,
+        profile: typeof record.profile === "string" ? record.profile : undefined,
+        sharedSessionId,
+        sharedThreadId: kind === "codex" || kind === "opencode"
+            ? sharedSessionId
+            : typeof record.sharedThreadId === "string"
+                ? record.sharedThreadId
+                : undefined,
+        resumeConversationId: typeof record.resumeConversationId === "string" ? record.resumeConversationId : undefined,
+        transcriptPath: typeof record.transcriptPath === "string" ? record.transcriptPath : undefined,
+        companionPid: typeof record.companionPid === "number" ? record.companionPid : undefined,
+        companionConnectedAt: typeof record.companionConnectedAt === "string" ? record.companionConnectedAt : undefined,
+        companionStatus: typeof record.companionStatus === "string"
+            ? record.companionStatus
+            : undefined,
+        companionLastStateAt: typeof record.companionLastStateAt === "string" ? record.companionLastStateAt : undefined,
+        companionWorkerPid: typeof record.companionWorkerPid === "number" ? record.companionWorkerPid : undefined,
+        startedAt: record.startedAt,
+    };
+}
+export function buildLocalCompanionToken() {
+    return crypto.randomBytes(18).toString("hex");
+}
+function serializeEndpoint(endpoint) {
+    return {
+        ...endpoint,
+        protocolVersion: endpoint.protocolVersion ?? LOCAL_CLIENT_PROTOCOL_VERSION,
+        sharedThreadId: endpoint.kind === "codex" || endpoint.kind === "opencode"
+            ? endpoint.sharedSessionId ?? endpoint.sharedThreadId
+            : undefined,
+    };
+}
+function readEndpointFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return normalizeEndpoint(JSON.parse(fs.readFileSync(filePath, "utf8")));
+}
+export function writeLocalCompanionEndpoint(endpoint, options = {}) {
+    const { endpointFile } = ensureWorkspaceChannelDir(endpoint.cwd);
+    const payload = {
+        ...serializeEndpoint(endpoint),
+    };
+    fs.writeFileSync(getWorkspaceAdapterEndpointFile(endpoint.cwd, endpoint.kind), JSON.stringify(payload, null, 2), "utf8");
+    if (options.writeLegacy !== false) {
+        fs.writeFileSync(endpointFile, JSON.stringify(payload, null, 2), "utf8");
+    }
+}
+export function readLocalCompanionEndpoint(cwd, options = {}) {
+    try {
+        const { endpointFile } = getWorkspaceChannelPaths(cwd);
+        if (options.adapter) {
+            const scoped = readEndpointFile(getWorkspaceAdapterEndpointFile(cwd, options.adapter));
+            if (scoped) {
+                return scoped;
+            }
+            const legacy = readEndpointFile(endpointFile);
+            return legacy?.kind === options.adapter ? legacy : null;
+        }
+        return readEndpointFile(endpointFile);
+    }
+    catch {
+        return null;
+    }
+}
+export function clearLocalCompanionEndpoint(cwd, instanceId, options = {}) {
+    try {
+        const { endpointFile } = getWorkspaceChannelPaths(cwd);
+        const files = options.adapter
+            ? [getWorkspaceAdapterEndpointFile(cwd, options.adapter), endpointFile]
+            : [
+                endpointFile,
+                getWorkspaceAdapterEndpointFile(cwd, "codex"),
+                getWorkspaceAdapterEndpointFile(cwd, "claude"),
+                getWorkspaceAdapterEndpointFile(cwd, "opencode"),
+                getWorkspaceAdapterEndpointFile(cwd, "shell"),
+            ];
+        for (const filePath of files) {
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            if (!instanceId) {
+                fs.rmSync(filePath, { force: true });
+                continue;
+            }
+            const endpoint = readEndpointFile(filePath);
+            if (!endpoint || endpoint.instanceId === instanceId) {
+                fs.rmSync(filePath, { force: true });
+            }
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function clearLocalCompanionOccupancy(cwd, instanceId, options = {}) {
+    try {
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
+        if (!endpoint) {
+            return;
+        }
+        if (instanceId && endpoint.instanceId !== instanceId) {
+            return;
+        }
+        writeLocalCompanionEndpoint({
+            ...endpoint,
+            companionPid: undefined,
+            companionConnectedAt: undefined,
+            companionStatus: undefined,
+            companionLastStateAt: undefined,
+            companionWorkerPid: undefined,
+        });
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function updateLocalCompanionHealth(cwd, patch, instanceId, options = {}) {
+    try {
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
+        if (!endpoint) {
+            return;
+        }
+        if (instanceId && endpoint.instanceId !== instanceId) {
+            return;
+        }
+        writeLocalCompanionEndpoint({
+            ...endpoint,
+            companionStatus: patch.companionStatus,
+            companionLastStateAt: patch.companionLastStateAt,
+            companionWorkerPid: patch.companionWorkerPid,
+        });
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function updateLocalCompanionOccupancy(cwd, patch, instanceId, options = {}) {
+    try {
+        const endpoint = readLocalCompanionEndpoint(cwd, options);
+        if (!endpoint) {
+            return;
+        }
+        if (instanceId && endpoint.instanceId !== instanceId) {
+            return;
+        }
+        writeLocalCompanionEndpoint({
+            ...endpoint,
+            companionPid: patch.companionPid,
+            companionConnectedAt: patch.companionConnectedAt,
+        });
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function sendLocalCompanionMessage(socket, message) {
+    if (socket.destroyed || socket.writableEnded) {
+        return false;
+    }
+    try {
+        return socket.write(`${JSON.stringify(message)}\n`);
+    }
+    catch {
+        return false;
+    }
+}
+export function attachLocalCompanionMessageListener(socket, onMessage) {
+    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 {
+                onMessage(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed local IPC frames.
+            }
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", onData);
+    return () => {
+        socket.off("data", onData);
+    };
+}