cli-wechat-bridge 1.1.6 → 1.1.8

package/dist/channels/wecom/wecom-transport.js

@@ -0,0 +1,308 @@
+import fs from "node:fs";
+import path from "node:path";
+import { generateReqId, WSAuthFailureError, WSClient, WSReconnectExhaustedError, } from "@wecom/aibot-node-sdk";
+import { tryClaimChannelInboundMessage } from "../../core/inbound-message-claims.js";
+import { downloadWecomInboundAttachments, } from "./wecom-media.js";
+import { parseWecomInboundFrame, toWecomChannelInboundMessage, } from "./wecom-message.js";
+import { WECOM_INBOUND_MESSAGE_CLAIMS_DIR, } from "./wecom-config.js";
+const WECOM_TEXT_MAX_BYTES = 20_480;
+const WECOM_TEXT_CHUNK_BYTES = 18_000;
+const WECOM_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+const WECOM_VIDEO_MAX_BYTES = 10 * 1024 * 1024;
+const WECOM_VOICE_MAX_BYTES = 2 * 1024 * 1024;
+const WECOM_FILE_MAX_BYTES = 20 * 1024 * 1024;
+function createDefaultClient(account, logger) {
+    return new WSClient({
+        botId: account.botId,
+        secret: account.secret,
+        maxReconnectAttempts: 10,
+        maxAuthFailureAttempts: 5,
+        heartbeatInterval: 30_000,
+        maxReplyQueueSize: 500,
+        logger: {
+            debug: (message, ...args) => logger.log?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+            info: (message, ...args) => logger.log?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+            warn: (message, ...args) => logger.log?.(`[wecom-sdk] WARN: ${message} ${args.join(" ")}`.trim()),
+            error: (message, ...args) => logger.error?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+        },
+    });
+}
+function splitUtf8Text(text, maxBytes = WECOM_TEXT_CHUNK_BYTES) {
+    if (Buffer.byteLength(text, "utf-8") <= maxBytes) {
+        return [text];
+    }
+    const chunks = [];
+    let current = "";
+    let bytes = 0;
+    for (const character of text) {
+        const nextBytes = Buffer.byteLength(character, "utf-8");
+        if (current && bytes + nextBytes > maxBytes) {
+            chunks.push(current);
+            current = "";
+            bytes = 0;
+        }
+        current += character;
+        bytes += nextBytes;
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+function getChatType(target) {
+    return target.metadata?.chatType === "group" ? "group" : "direct";
+}
+function getReplyFrame(target) {
+    return target.opaqueRef
+        ? { headers: { req_id: target.opaqueRef } }
+        : null;
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const known = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".amr": "audio/amr",
+        ".mp4": "video/mp4",
+        ".pdf": "application/pdf",
+        ".txt": "text/plain",
+    };
+    return known[ext] || "application/octet-stream";
+}
+function resolveOutboundMedia(attachment) {
+    const fileName = attachment.fileName || path.basename(attachment.path);
+    const size = fs.statSync(attachment.path).size;
+    const mimeType = attachment.mimeType || inferMimeType(attachment.path);
+    if (attachment.kind === "image" &&
+        size <= WECOM_IMAGE_MAX_BYTES &&
+        ["image/jpeg", "image/png", "image/gif"].includes(mimeType)) {
+        return { type: "image", maxBytes: WECOM_IMAGE_MAX_BYTES, fileName };
+    }
+    if (attachment.kind === "voice" &&
+        size <= WECOM_VOICE_MAX_BYTES &&
+        path.extname(fileName).toLowerCase() === ".amr") {
+        return { type: "voice", maxBytes: WECOM_VOICE_MAX_BYTES, fileName };
+    }
+    if (attachment.kind === "video" &&
+        size <= WECOM_VIDEO_MAX_BYTES &&
+        path.extname(fileName).toLowerCase() === ".mp4") {
+        return { type: "video", maxBytes: WECOM_VIDEO_MAX_BYTES, fileName };
+    }
+    return { type: "file", maxBytes: WECOM_FILE_MAX_BYTES, fileName };
+}
+export class WecomTransport {
+    account;
+    client;
+    logger;
+    claimsDir;
+    attachmentsDir;
+    fetchImpl;
+    streamStates = new Map();
+    inboundChains = new Map();
+    outputChain = Promise.resolve();
+    authenticated = false;
+    started = false;
+    onMessage = null;
+    onUnauthorized = null;
+    onFatal = null;
+    onConnected = null;
+    constructor(options) {
+        this.account = options.account;
+        this.logger = options.logger ?? {};
+        this.claimsDir = options.claimsDir ?? WECOM_INBOUND_MESSAGE_CLAIMS_DIR;
+        this.attachmentsDir = options.attachmentsDir;
+        this.fetchImpl = options.fetchImpl;
+        this.client = (options.clientFactory ?? createDefaultClient)(this.account, this.logger);
+        this.attachClientEvents();
+    }
+    attachClientEvents() {
+        this.client.on("authenticated", () => {
+            this.authenticated = true;
+            this.logger.log?.("wecom_authenticated");
+            void this.onConnected?.();
+        });
+        this.client.on("disconnected", (reason) => {
+            this.authenticated = false;
+            this.logger.log?.(`wecom_disconnected: reason=${reason}`);
+        });
+        this.client.on("reconnecting", (attempt) => {
+            this.logger.log?.(`wecom_reconnecting: attempt=${attempt}`);
+        });
+        this.client.on("event.disconnected_event", () => {
+            const error = new Error("The WeCom bot was connected by another process. This connection was stopped to avoid a reconnect loop.");
+            this.authenticated = false;
+            this.client.disconnect();
+            void this.onFatal?.(error);
+        });
+        this.client.on("error", (error) => {
+            this.logger.error?.(`wecom_transport_error: ${error.message}`);
+            if (error instanceof WSAuthFailureError ||
+                error instanceof WSReconnectExhaustedError) {
+                void this.onFatal?.(error);
+            }
+        });
+        this.client.on("message", (frame) => {
+            void this.handleInboundFrame(frame).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logger.error?.(`wecom_inbound_failed: ${message}`);
+            });
+        });
+    }
+    setHandlers(handlers) {
+        this.onMessage = handlers.onMessage;
+        this.onUnauthorized = handlers.onUnauthorized ?? null;
+        this.onFatal = handlers.onFatal ?? null;
+        this.onConnected = handlers.onConnected ?? null;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.client.connect();
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        this.started = false;
+        this.authenticated = false;
+        this.streamStates.clear();
+        this.client.disconnect();
+    }
+    get isConnected() {
+        return this.authenticated && this.client.isConnected;
+    }
+    async waitUntilConnected(timeoutMs = 15_000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (this.isConnected) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new Error("Timed out waiting for WeCom WebSocket authentication.");
+    }
+    async handleInboundFrame(frame) {
+        const parsed = parseWecomInboundFrame(frame);
+        if (!parsed) {
+            return;
+        }
+        if (parsed.senderId !== this.account.operatorUserId) {
+            await this.onUnauthorized?.(parsed.senderId, parsed.chatType);
+            return;
+        }
+        if (!tryClaimChannelInboundMessage(`${this.account.botId}|${parsed.id}`, {
+            claimsDir: this.claimsDir,
+        })) {
+            this.logger.log?.(`wecom_duplicate_skipped: msgid=${parsed.id}`);
+            return;
+        }
+        const queueKey = `${this.account.botId}:${parsed.conversationId}`;
+        const previous = this.inboundChains.get(queueKey) ?? Promise.resolve();
+        const deliver = async () => {
+            const downloaded = await downloadWecomInboundAttachments(parsed, {
+                attachmentsDir: this.attachmentsDir,
+                fetchImpl: this.fetchImpl,
+            });
+            const text = [parsed.text, ...downloaded.failureNotes]
+                .filter(Boolean)
+                .join("\n")
+                .trim();
+            await this.onMessage?.(toWecomChannelInboundMessage({ ...parsed, text }, downloaded.attachments, this.account.botId));
+        };
+        const next = previous.then(deliver, deliver);
+        this.inboundChains.set(queueKey, next);
+        try {
+            await next;
+        }
+        finally {
+            if (this.inboundChains.get(queueKey) === next) {
+                this.inboundChains.delete(queueKey);
+            }
+        }
+    }
+    queueOutput(action) {
+        const run = this.outputChain.then(action);
+        this.outputChain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async sendActiveText(target, text) {
+        for (const chunk of splitUtf8Text(text)) {
+            if (Buffer.byteLength(chunk, "utf-8") > WECOM_TEXT_MAX_BYTES) {
+                throw new Error("WeCom text chunk exceeds the 20480-byte platform limit.");
+            }
+            await this.client.sendMessage(target.recipientId, {
+                msgtype: "markdown",
+                markdown: { content: chunk },
+            });
+        }
+    }
+    async sendText(target, text, kind) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return true;
+        }
+        return this.queueOutput(async () => {
+            if (!this.isConnected) {
+                throw new Error("WeCom WebSocket is not connected.");
+            }
+            const chunks = splitUtf8Text(normalized);
+            const replyFrame = getReplyFrame(target);
+            const canUseStream = Boolean(replyFrame) && (kind === "thinking" || kind === "final_reply");
+            if (!canUseStream) {
+                await this.sendActiveText(target, normalized);
+                return true;
+            }
+            const reqId = target.opaqueRef;
+            const state = this.streamStates.get(reqId) ?? {
+                streamId: generateReqId("stream"),
+                finished: false,
+            };
+            this.streamStates.set(reqId, state);
+            try {
+                if (kind === "thinking") {
+                    const result = await this.client.replyStreamNonBlocking(replyFrame, state.streamId, chunks[0], false);
+                    return result !== "skipped";
+                }
+                await this.client.replyStream(replyFrame, state.streamId, chunks[0], true);
+                state.finished = true;
+                this.streamStates.delete(reqId);
+                for (const chunk of chunks.slice(1)) {
+                    await this.sendActiveText(target, chunk);
+                }
+                return true;
+            }
+            catch (error) {
+                if (kind !== "final_reply") {
+                    throw error;
+                }
+                this.streamStates.delete(reqId);
+                this.logger.log?.(`wecom_stream_fallback: reqid=${reqId} chat_type=${getChatType(target)}`);
+                await this.sendActiveText(target, normalized);
+                return true;
+            }
+        });
+    }
+    async sendAttachment(target, attachment) {
+        await this.queueOutput(async () => {
+            if (!this.isConnected) {
+                throw new Error("WeCom WebSocket is not connected.");
+            }
+            const media = resolveOutboundMedia(attachment);
+            const buffer = fs.readFileSync(attachment.path);
+            if (buffer.length > media.maxBytes) {
+                throw new Error(`${media.type} attachment exceeds the ${Math.round(media.maxBytes / 1024 / 1024)} MB WeCom limit`);
+            }
+            const uploaded = await this.client.uploadMedia(buffer, {
+                type: media.type,
+                filename: media.fileName,
+            });
+            await this.client.sendMediaMessage(target.recipientId, media.type, uploaded.media_id, media.type === "video"
+                ? { title: media.fileName, description: "" }
+                : undefined);
+        });
+    }
+}

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

@@ -5,10 +5,11 @@ import net from "node:net";
 import path from "node:path";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, buildCodexCliArgs, resolveSpawnTarget, } from "../bridge/bridge-adapters.shared.js";
 import { killProcessTreeSync } from "../bridge/bridge-process-reaper.js";
-import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
+import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleControlRequest, sendCodexVisibleShutdownResponse, 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";
+import { isDirectModuleRun } from "../core/direct-run.js";
 const CODEX_VISIBLE_SWITCH_SETTLE_MS = 500;
 const CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS = 2_000;
 function log(message) {
@@ -301,11 +302,20 @@ export class CodexVisibleClientSupervisor {
                     socket.destroy();
                     return;
                 }
-                const request = parseCodexVisibleSwitchRequest(parsed);
+                const request = parseCodexVisibleControlRequest(parsed);
                 if (!request || request.token !== this.controlToken) {
                     socket.destroy();
                     return;
                 }
+                if (request.type === "shutdown") {
+                    sendCodexVisibleShutdownResponse(socket, {
+                        type: "shutdown_result",
+                        id: request.id,
+                        ok: true,
+                    });
+                    void this.shutdownFromControl();
+                    return;
+                }
                 void this.switchThread(request.threadId).then(() => {
                     sendCodexVisibleSwitchResponse(socket, {
                         type: "switch_thread_result",
@@ -339,6 +349,17 @@ export class CodexVisibleClientSupervisor {
         this.controlServer = server;
         this.controlPort = address.port;
     }
+    async shutdownFromControl() {
+        await this.switchChain.catch(() => undefined);
+        if (this.runSettled) {
+            return;
+        }
+        const child = this.child;
+        if (child) {
+            await this.stopChild(child);
+        }
+        this.finishRun(undefined, 0);
+    }
     async closeControlServer() {
         const server = this.controlServer;
         this.controlServer = null;
@@ -388,7 +409,7 @@ async function main() {
     const exitCode = await runCodexRemoteClient(options);
     process.exit(exitCode);
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     main().catch((error) => {
         log(error instanceof Error ? error.message : String(error));

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

@@ -23,12 +23,37 @@ export function parseCodexVisibleSwitchRequest(value) {
         threadId: value.threadId,
     };
 }
+export function parseCodexVisibleControlRequest(value) {
+    const switchRequest = parseCodexVisibleSwitchRequest(value);
+    if (switchRequest) {
+        return switchRequest;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.type !== "shutdown" ||
+        typeof value.id !== "string" ||
+        typeof value.token !== "string") {
+        return null;
+    }
+    return {
+        type: "shutdown",
+        id: value.id,
+        token: value.token,
+    };
+}
 export function sendCodexVisibleSwitchResponse(socket, response) {
     if (socket.destroyed || socket.writableEnded) {
         return;
     }
     socket.end(`${JSON.stringify(response)}\n`);
 }
+export function sendCodexVisibleShutdownResponse(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) {
@@ -120,3 +145,79 @@ export async function requestCodexVisibleThreadSwitch(params) {
         });
     });
 }
+export async function requestCodexVisibleClientShutdown(params) {
+    const endpoint = resolveCodexControlEndpoint(params.cwd, params.instanceId);
+    const requestId = crypto.randomUUID();
+    const timeoutMs = params.timeoutMs ?? 5_000;
+    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) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => {
+            const request = {
+                type: "shutdown",
+                id: requestId,
+                token: endpoint.codexControlToken,
+            };
+            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 shutdown 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 shutdown response."));
+                return;
+            }
+            if (!isRecord(parsed) || parsed.type !== "shutdown_result" || parsed.id !== requestId) {
+                finish(new Error("The visible Codex client returned an unexpected shutdown response."));
+                return;
+            }
+            if (parsed.ok !== true) {
+                finish(new Error(typeof parsed.error === "string"
+                    ? parsed.error
+                    : "The visible Codex client could not shut down."));
+                return;
+            }
+            finish();
+        });
+        socket.once("timeout", () => {
+            finish(new Error("Timed out waiting for the visible Codex client to shut down."));
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled) {
+                finish(new Error("The visible Codex client closed the shutdown connection."));
+            }
+        });
+    });
+}

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);
@@ -37,8 +39,13 @@ export function formatSwitchFailureMessage(cwd) {
 export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
-export function defaultSessionStartMode(adapter) {
-    return adapter === "codex" ? "restore" : "new";
+export function defaultSessionStartMode(_adapter) {
+    // Codex 0.155+ persists app-server threads lazily, so launching the visible
+    // client with a freshly prepared (not yet persisted) thread id crashes its
+    // bootstrap with "no rollout found". Start every adapter fresh by default;
+    // explicit --session-start-mode restore remains available for deliberate
+    // restores of already persisted threads.
+    return "new";
 }
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
@@ -48,6 +55,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 +108,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 +118,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 +128,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 +146,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 +207,7 @@ export function parseCliArgs(argv) {
         timeoutMs,
         sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
+        channelId,
     };
 }
 function isPidAlive(pid) {
@@ -295,6 +314,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 +383,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 +431,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 +457,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 +484,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 +500,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 +524,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();
 }