cli-wechat-bridge 1.1.5 → 1.1.7

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

@@ -5,6 +5,8 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
+import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
 import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
 import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
 import { runCodexRemoteClient } from "./codex-remote-client.js";
@@ -15,8 +17,8 @@ const MODULE_DIR = path.dirname(MODULE_FILE);
 const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
-function log(adapter, message) {
-    process.stderr.write(`[wechat-${adapter}] ${message}\n`);
+function log(adapter, message, channelId = "wechat") {
+    process.stderr.write(`[${channelId}-${adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -48,6 +50,8 @@ export function decideLaunchAction(input) {
         };
     }
     const sameWorkspace = input.runningLock.adapter === input.requestedAdapter &&
+        (input.runningLock.channelId ?? "wechat") ===
+            (input.requestedChannelId ?? "wechat") &&
         isSameWorkspaceCwd(input.runningLock.cwd, input.requestedCwd);
     if (!sameWorkspace) {
         return {
@@ -99,6 +103,7 @@ export function parseCliArgs(argv) {
     let profile;
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
     let sessionStartMode;
+    let channelId = "wechat";
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -108,7 +113,7 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             const helpAdapter = adapter;
-            const commandName = `wechat-${helpAdapter}`;
+            const commandName = `${channelId}-${helpAdapter}`;
             const adapterLabel = {
                 codex: "Codex",
                 claude: "Claude Code",
@@ -118,7 +123,7 @@ export function parseCliArgs(argv) {
             process.stdout.write([
                 `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                "Ensures the WeChat runtime for the current directory, then opens or reuses the visible CLI.",
+                `Ensures the ${channelId === "wecom" ? "WeCom" : "WeChat"} runtime for the current directory, then opens or reuses the visible CLI.`,
                 "If a same-workspace daemon is running, the command delegates to that daemon.",
                 helpAdapter === "codex"
                     ? "Codex restores the current session by default."
@@ -136,6 +141,14 @@ export function parseCliArgs(argv) {
         if (arg === "--doctor") {
             continue;
         }
+        if (arg === "--channel") {
+            if (!next || (next !== "wechat" && next !== "wecom")) {
+                throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+            }
+            channelId = next;
+            i += 1;
+            continue;
+        }
         if (arg === "--adapter") {
             if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -189,6 +202,7 @@ export function parseCliArgs(argv) {
         timeoutMs,
         sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
+        channelId,
     };
 }
 function isPidAlive(pid) {
@@ -295,6 +309,9 @@ export function buildBackgroundBridgeArgs(entryPath, options) {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
+    if (options.channelId === "wecom") {
+        args.push("--channel", "wecom");
+    }
     if (options.sessionStartMode !== "restore") {
         args.push("--session-start-mode", options.sessionStartMode);
     }
@@ -361,6 +378,7 @@ async function ensureBridgeReady(options) {
         endpointIsReachable: Boolean(endpointResult.endpoint),
         companionIsAlive: isCompanionAlive(endpointResult.endpoint),
         sessionStartMode: options.sessionStartMode,
+        requestedChannelId: options.channelId,
     });
     log(options.adapter, decision.message);
     if (decision.kind === "already_active") {
@@ -408,8 +426,13 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         clearEndpoint(endpoint.pid);
         return false;
     }
+    const requestedChannel = options.channelId ?? "wechat";
+    const endpointChannel = endpoint.channelId ?? "wechat";
+    if (requestedChannel !== endpointChannel) {
+        throw new Error(`${endpointChannel}-daemon is running for ${endpoint.cwd}. Stop it before starting the ${requestedChannel} channel.`);
+    }
     if (!isSameWorkspaceCwd(endpoint.cwd, options.cwd)) {
-        throw new Error(`wechat-daemon is running for ${endpoint.cwd}. This launcher requested ${options.cwd}; v1 daemon switching is limited to its startup cwd.`);
+        throw new Error(`${requestedChannel}-daemon is running for ${endpoint.cwd}. This launcher requested ${options.cwd}; v1 daemon switching is limited to its startup cwd.`);
     }
     const response = await sendRequest(endpoint, {
         command: "ensure_slot",
@@ -429,7 +452,7 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
         return false;
     }
-    log(options.adapter, `Delegated to running wechat-daemon for ${options.cwd}.`);
+    log(options.adapter, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`, requestedChannel);
     return true;
 }
 export async function runVisibleClient(options, runners = {}) {
@@ -456,6 +479,15 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
         log: (message) => log(adapter, message),
     });
 }
+export async function ensureCompanionStartChannelCredentials(options) {
+    if (options.channelId === "wecom") {
+        await ensureWecomAccount({
+            log: (message) => log(options.adapter, message, "wecom"),
+        });
+        return;
+    }
+    await ensureCompanionStartWechatCredentials(options.adapter);
+}
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {
         const { runDoctorCheck } = await import("../utils/doctor.js");
@@ -463,7 +495,7 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
         return 0;
     }
     const options = parseCliArgs(argv);
-    await ensureCompanionStartWechatCredentials(options.adapter);
+    await ensureCompanionStartChannelCredentials(options);
     if (await tryDelegateToDaemon(options)) {
         return 0;
     }
@@ -487,11 +519,19 @@ export async function main(argv = process.argv.slice(2)) {
                 return DEFAULT_ADAPTER;
             }
         })();
-        log(adapter, error instanceof Error ? error.message : String(error));
+        const channelId = (() => {
+            try {
+                return parseCliArgs(argv).channelId ?? "wechat";
+            }
+            catch {
+                return "wechat";
+            }
+        })();
+        log(adapter, error instanceof Error ? error.message : String(error), channelId);
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }

package/dist/companion/local-companion.js

@@ -6,6 +6,7 @@ import { LOCAL_COMPANION_RECONNECT_GRACE_MS, } from "../bridge/bridge-adapters.s
 import { runCodexRemoteClientFromEndpoint } from "./codex-remote-client.js";
 import { attachLocalCompanionMessageListener, readLocalCompanionEndpoint, sendLocalCompanionMessage, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
 export const LOCAL_COMPANION_RECONNECT_RETRY_MS = 250;
 function log(adapter, message) {
     process.stderr.write(`[${adapter}-companion] ${message}\n`);
@@ -439,7 +440,7 @@ export async function main(argv = process.argv.slice(2)) {
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }

package/dist/core/bridge-control.js

@@ -0,0 +1,32 @@
+/** Parse the canonical control command grammar shared by all channels. */
+export function parseBridgeControlCommand(text) {
+    const [rawCommand, ...rest] = text.trim().split(/\s+/);
+    if (!rawCommand?.startsWith("/")) {
+        return null;
+    }
+    const command = rawCommand.toLowerCase();
+    const argument = rest.join(" ").trim();
+    switch (command) {
+        case "/status":
+            return { type: "status" };
+        case "/resume":
+            return argument ? { type: "resume", target: argument } : { type: "resume" };
+        case "/new":
+        case "/new-session":
+            return { type: "new_session" };
+        case "/stop":
+            return { type: "stop" };
+        case "/reset":
+            return { type: "reset" };
+        case "/confirm":
+        case "/yes":
+            return { type: "confirm" };
+        case "/deny":
+        case "/no":
+            return { type: "deny" };
+        case "/answer":
+            return argument ? { type: "answer", raw: argument } : null;
+        default:
+            return null;
+    }
+}

package/dist/core/bridge-event-forwarder.js

@@ -0,0 +1,50 @@
+/** Dispatch a BridgeEvent without importing any channel or transport code. */
+export async function forwardBridgeEvent(event, handlers) {
+    switch (event.type) {
+        case "stdout":
+            await handlers.stdout?.(event);
+            return;
+        case "stderr":
+            await handlers.stderr?.(event);
+            return;
+        case "final_reply":
+            await handlers.finalReply?.(event);
+            return;
+        case "status":
+            await handlers.status?.(event);
+            return;
+        case "notice":
+            await handlers.notice?.(event);
+            return;
+        case "thinking":
+            await handlers.thinking?.(event);
+            return;
+        case "approval_required":
+            await handlers.approvalRequired?.(event);
+            return;
+        case "user_input_required":
+            await handlers.userInputRequired?.(event);
+            return;
+        case "mirrored_user_input":
+            await handlers.mirroredUserInput?.(event);
+            return;
+        case "session_switched":
+            await handlers.sessionSwitched?.(event);
+            return;
+        case "thread_switched":
+            await handlers.threadSwitched?.(event);
+            return;
+        case "task_complete":
+            await handlers.taskComplete?.(event);
+            return;
+        case "task_failed":
+            await handlers.taskFailed?.(event);
+            return;
+        case "fatal_error":
+            await handlers.fatalError?.(event);
+            return;
+        case "shutdown_requested":
+            await handlers.shutdownRequested?.(event);
+            return;
+    }
+}

package/dist/core/bridge-message-router.js

@@ -0,0 +1,32 @@
+/**
+ * Common, channel-neutral ordering for an inbound bridge message.
+ * Channel-specific parsing and daemon slot selection stay outside this
+ * function and are supplied through callbacks.
+ */
+export async function routeBridgeMessage(context) {
+    if (!context.authorized) {
+        await context.onUnauthorized();
+        return { kind: "handled" };
+    }
+    if (context.command && await context.handleCommand(context.command)) {
+        return { kind: "handled" };
+    }
+    if (context.hasPendingApproval) {
+        await context.remindPendingApproval();
+        return { kind: "handled" };
+    }
+    if (context.hasPendingUserInput || context.adapterState.status === "awaiting_input") {
+        await context.remindPendingUserInput();
+        return { kind: "handled" };
+    }
+    if (context.shouldDefer) {
+        await context.defer();
+        return { kind: "deferred" };
+    }
+    if (context.adapterState.status === "busy" ||
+        context.adapterState.status === "awaiting_approval") {
+        await context.remindBusy();
+        return { kind: "handled" };
+    }
+    return { kind: "dispatched", result: await context.dispatch() };
+}

package/dist/core/channel-types.js

@@ -0,0 +1,3 @@
+export function normalizeBridgeChannelId(value) {
+    return value === "wecom" ? "wecom" : "wechat";
+}

package/dist/core/direct-run.js

@@ -0,0 +1,17 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function normalizeComparablePath(filePath) {
+    const normalized = path.resolve(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+export function isDirectModuleRun(importMetaUrl, argv = process.argv, importMetaMain) {
+    if (typeof importMetaMain === "boolean") {
+        return importMetaMain;
+    }
+    const entryPath = argv[1];
+    if (!entryPath) {
+        return false;
+    }
+    return normalizeComparablePath(fileURLToPath(importMetaUrl)) ===
+        normalizeComparablePath(entryPath);
+}

package/dist/core/inbound-message-claims.js

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+export const DEFAULT_INBOUND_MESSAGE_CLAIM_TTL_MS = 10 * 60 * 1000;
+export function buildInboundMessageClaimPath(messageKey, claimsDir) {
+    const fileName = `${crypto.createHash("sha1").update(messageKey).digest("hex")}.json`;
+    return path.join(claimsDir, fileName);
+}
+export function tryClaimChannelInboundMessage(messageKey, options) {
+    if (!messageKey) {
+        return false;
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const ttlMs = options.ttlMs ?? DEFAULT_INBOUND_MESSAGE_CLAIM_TTL_MS;
+    const claimPath = buildInboundMessageClaimPath(messageKey, options.claimsDir);
+    const attemptClaim = () => {
+        fs.mkdirSync(options.claimsDir, { recursive: true });
+        const handle = fs.openSync(claimPath, "wx");
+        try {
+            fs.writeFileSync(handle, JSON.stringify({
+                key: messageKey,
+                claimedAt: new Date(nowMs).toISOString(),
+                pid: process.pid,
+            }, null, 2), "utf-8");
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+        return true;
+    };
+    try {
+        return attemptClaim();
+    }
+    catch (error) {
+        const code = typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            typeof error.code === "string"
+            ? error.code
+            : "";
+        if (code !== "EEXIST") {
+            return false;
+        }
+    }
+    try {
+        const stat = fs.statSync(claimPath);
+        if (Number.isFinite(stat.mtimeMs) && nowMs - stat.mtimeMs > ttlMs) {
+            fs.rmSync(claimPath, { force: true });
+            return attemptClaim();
+        }
+    }
+    catch {
+        try {
+            return attemptClaim();
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/core/text-utils.js

@@ -0,0 +1,63 @@
+const ANSI_ESCAPE_RE = 
+// eslint-disable-next-line no-control-regex
+/\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function stripAnsi(text) {
+    return text.replace(ANSI_ESCAPE_RE, "");
+}
+export function normalizeOutput(text) {
+    return stripAnsi(text)
+        // eslint-disable-next-line no-control-regex
+        .replace(/\u0000/g, "")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n");
+}
+export function truncatePreview(text, maxLength = 140) {
+    const normalized = normalizeOutput(text).trim().replace(/\s+/g, " ");
+    if (!normalized) {
+        return "(empty)";
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function buildOneTimeCode(length = 6) {
+    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+    let code = "";
+    while (code.length < length) {
+        code += alphabet[Math.floor(Math.random() * alphabet.length)];
+    }
+    return code;
+}
+export function buildInstanceId() {
+    return `bridge-${Date.now().toString(36)}-${buildOneTimeCode(6).toLowerCase()}`;
+}
+export function formatDuration(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < 0) {
+        return "0s";
+    }
+    const totalSeconds = Math.floor(durationMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (!minutes) {
+        return `${seconds}s`;
+    }
+    return `${minutes}m ${seconds}s`;
+}
+export function summarizeOutput(text, maxLength = 280) {
+    const normalized = normalizeOutput(text)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (!normalized.length) {
+        return "(no output)";
+    }
+    const summary = normalized.slice(-6).join("\n");
+    if (summary.length <= maxLength) {
+        return summary;
+    }
+    return summary.slice(summary.length - maxLength);
+}

package/dist/daemon/daemon-link.js

@@ -23,6 +23,9 @@ function normalizeDaemonEndpoint(value) {
         token: record.token,
         cwd: record.cwd,
         startedAt: record.startedAt,
+        ...(record.channelId === "wechat" || record.channelId === "wecom"
+            ? { channelId: record.channelId }
+            : {}),
     };
 }
 export function buildDaemonToken() {