cli-wechat-bridge 1.1.6 → 1.1.7

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

@@ -9,6 +9,7 @@ import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVi
 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) {
@@ -388,7 +389,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/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/channel-types.js

@@ -1 +1,3 @@
-export {};
+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/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() {