@unlinearity/cli-wechat-bridge 1.1.5 → 1.1.6

package/dist/channels/wechat/bridge-final-reply.js

@@ -0,0 +1,65 @@
+import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, splitWechatTextIntoChunks, } from "../../bridge/bridge-utils.js";
+export const OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE = "OpenCode 没有产生可发送到微信的可见回复。请查看本地终端输出，或重试这条消息。";
+export async function forwardWechatFinalReply(params) {
+    const { adapter, rawText, sender, onEmptyVisibleReply } = params;
+    const parsed = parseWechatFinalReply(rawText);
+    const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
+    const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
+    if (visibleText) {
+        // Send long replies in bounded chunks: a single oversized sendmessage call
+        // can be rejected by the WeChat API, silently losing the whole reply.
+        const chunks = splitWechatTextIntoChunks(visibleText);
+        for (let index = 0; index < chunks.length; index += 1) {
+            const sent = await sender.sendText(chunks[index]);
+            if (sent === false) {
+                // The send channel is failing (e.g. an expired context token).
+                // Report what was dropped instead of ending mid-reply silently;
+                // this notice itself is best effort and may also fail.
+                const remainingChunks = chunks.length - index - 1;
+                if (remainingChunks > 0 || parsed.attachments.length > 0) {
+                    const parts = [];
+                    if (remainingChunks > 0) {
+                        parts.push(`${remainingChunks} reply chunk(s)`);
+                    }
+                    if (parsed.attachments.length > 0) {
+                        parts.push(`${parsed.attachments.length} attachment(s)`);
+                    }
+                    await sender.sendText(`[bridge] Reply delivery was interrupted; ${parts.join(" and ")} could not be sent. Send a new message to retry.`);
+                }
+                return;
+            }
+        }
+    }
+    else if (adapter === "opencode" && parsed.visibleText.trim()) {
+        onEmptyVisibleReply?.({
+            adapter,
+            rawVisibleText: parsed.visibleText,
+        });
+        const sent = await sender.sendText(OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE);
+        if (sent === false) {
+            return;
+        }
+    }
+    for (const attachment of parsed.attachments) {
+        try {
+            switch (attachment.kind) {
+                case "image":
+                    await sender.sendImage(attachment.path);
+                    break;
+                case "file":
+                    await sender.sendFile(attachment.path);
+                    break;
+                case "voice":
+                    await sender.sendVoice(attachment.path);
+                    break;
+                case "video":
+                    await sender.sendVideo(attachment.path);
+                    break;
+            }
+        }
+        catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error ?? "unknown error");
+            await sender.sendText(`Failed to send ${attachment.kind} attachment: ${attachment.path}\n${errorText}`);
+        }
+    }
+}

package/dist/channels/wechat/channel-message.js

@@ -0,0 +1,24 @@
+function toChannelAttachment(attachment) {
+    return {
+        kind: attachment.kind,
+        path: attachment.path,
+        fileName: attachment.fileName,
+        sizeBytes: attachment.sizeBytes,
+    };
+}
+/** Convert the WeChat transport shape into the channel-neutral core shape. */
+export function toChannelInboundMessage(message) {
+    return {
+        id: `${message.senderId}:${message.sessionId}:${message.createdAt}`,
+        conversation: {
+            channelId: "wechat",
+            conversationId: message.sessionId || message.senderId,
+            recipientId: message.senderId,
+            opaqueRef: message.contextToken,
+        },
+        senderId: message.senderId,
+        text: message.text,
+        attachments: message.attachments.map(toChannelAttachment),
+        createdAt: message.createdAt,
+    };
+}

package/dist/channels/wechat/index.js

@@ -0,0 +1,5 @@
+export * from "./bridge-final-reply.js";
+export * from "./channel-message.js";
+export * from "./wechat-channel-port.js";
+export * from "./wechat-forwarding.js";
+export * from "./wechat-outbound-queue.js";

package/dist/channels/wechat/wechat-channel-port.js

@@ -0,0 +1,67 @@
+import { forwardWechatFinalReply } from "./bridge-final-reply.js";
+function getRecipient(target) {
+    if (target.channelId !== "wechat") {
+        throw new Error(`WeChat channel cannot send to ${target.channelId}.`);
+    }
+    return target.recipientId;
+}
+function attachmentSender(deps, recipientId, attachment) {
+    switch (attachment.kind) {
+        case "image":
+            return deps.sendImage(recipientId, attachment.path);
+        case "file":
+            return deps.sendFile(recipientId, attachment.path);
+        case "voice":
+            return deps.sendVoice(recipientId, attachment.path);
+        case "video":
+            return deps.sendVideo(recipientId, attachment.path);
+    }
+}
+/**
+ * Channel boundary for WeChat output. The bridge core emits ChannelOutput;
+ * this port owns WeChat prefixes, final-reply parsing, and media dispatch.
+ */
+export class WechatChannelPort {
+    channelId = "wechat";
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async send(output) {
+        const recipientId = getRecipient(output.target);
+        const prefixText = (text) => this.deps.prefixText?.(output.adapter, text) ?? text;
+        const context = typeof output.metadata?.sendContext === "string"
+            ? output.metadata.sendContext
+            : output.kind;
+        if (output.kind === "final_reply") {
+            await forwardWechatFinalReply({
+                adapter: output.adapter ?? "codex",
+                rawText: output.text ?? "",
+                onEmptyVisibleReply: ({ rawVisibleText }) => {
+                    this.deps.onEmptyVisibleReply?.(output.adapter, rawVisibleText);
+                },
+                sender: {
+                    sendText: async (text) => {
+                        const sent = await this.deps.sendText(recipientId, prefixText(text), "final_reply");
+                        if (sent) {
+                            this.deps.onTextSent?.(output.adapter, text);
+                        }
+                        return sent;
+                    },
+                    sendImage: (filePath) => this.deps.sendImage(recipientId, filePath),
+                    sendFile: (filePath) => this.deps.sendFile(recipientId, filePath),
+                    sendVoice: (filePath) => this.deps.sendVoice(recipientId, filePath),
+                    sendVideo: (filePath) => this.deps.sendVideo(recipientId, filePath),
+                },
+            });
+            return true;
+        }
+        if (output.attachment) {
+            await attachmentSender(this.deps, recipientId, output.attachment);
+        }
+        if (output.text?.trim()) {
+            return Boolean(await this.deps.sendText(recipientId, prefixText(output.text), context));
+        }
+        return true;
+    }
+}

package/dist/channels/wechat/wechat-forwarding.js

@@ -0,0 +1,79 @@
+import { truncatePreview } from "../../bridge/bridge-utils.js";
+import { classifyWechatTransportError, describeWechatTransportError, isWechatContextTokenStaleError, } from "../../wechat/wechat-transport.js";
+export const WECHAT_SEND_MAX_ATTEMPTS = 3;
+export const CODEX_LOCAL_THREAD_NOTICE_SUPPRESS_MS = 500;
+const WECHAT_SEND_RETRY_BASE_MS = 750;
+export function formatUserFacingBridgeFatalError(message) {
+    return `Bridge error: ${message.replace(/\s+Recent app-server log:.*$/s, "").trim()}`;
+}
+export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {}) {
+    if (adapter !== "opencode" && adapter !== "pi") {
+        return true;
+    }
+    switch (eventType) {
+        case "stdout":
+        case "stderr":
+        case "thread_switched":
+            return false;
+        case "notice":
+            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
+        case "mirrored_user_input":
+            return true;
+        default:
+            return true;
+    }
+}
+/**
+ * Local Codex panels can emit a burst of weak thread notifications immediately
+ * after a WeChat reply. Suppress only the user-facing notice in that window;
+ * the adapter still updates its internal shared-thread state.
+ */
+export function shouldSuppressCodexLocalThreadNotice(params) {
+    if (params.adapter !== "codex" || params.source !== "local") {
+        return false;
+    }
+    if (typeof params.lastFinalReplyAtMs !== "number") {
+        return false;
+    }
+    const nowMs = params.nowMs ?? Date.now();
+    const elapsedMs = nowMs - params.lastFinalReplyAtMs;
+    return (elapsedMs >= 0 && elapsedMs < CODEX_LOCAL_THREAD_NOTICE_SUPPRESS_MS);
+}
+export function formatUserFacingInboundError(params) {
+    const { adapter, cwd, errorText } = params;
+    if (adapter === "opencode" &&
+        /opencode companion is not connected/i.test(errorText)) {
+        return cwd
+            ? `OpenCode is not connected for workspace:\n${cwd}\nRun "wechat-opencode" in that directory to recreate or reconnect the visible terminal.`
+            : 'OpenCode is not connected. Run "wechat-opencode" in this directory, then retry.';
+    }
+    return `Bridge error: ${errorText}`;
+}
+export function formatWechatSendFailureLogEntry(params) {
+    return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function formatWechatContextTokenStaleLogEntry(params) {
+    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function formatWechatSendRetryLogEntry(params) {
+    return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function isRetryableWechatSendError(error) {
+    if (isWechatContextTokenStaleError(error)) {
+        return false;
+    }
+    const classification = classifyWechatTransportError(error);
+    if (classification.retryable) {
+        return true;
+    }
+    const details = describeWechatTransportError(error);
+    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
+        !/errcode=-14\b.*session timeout/i.test(details);
+}
+export function isWechatContextUnavailableError(error) {
+    return (isWechatContextTokenStaleError(error) ||
+        (error instanceof Error && /No cached context token(?: is available| for )/i.test(error.message)));
+}
+export function computeWechatSendRetryDelayMs(attempt) {
+    return WECHAT_SEND_RETRY_BASE_MS * attempt;
+}

package/dist/channels/wechat/wechat-outbound-queue.js

@@ -0,0 +1,72 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { getWorkspaceChannelPaths } from "../../wechat/channel-config.js";
+import { writeJsonFileAtomic } from "../../utils/atomic-file.js";
+export function getPendingWechatMessagesFile(cwd) {
+    return path.join(getWorkspaceChannelPaths(cwd).workspaceDir, "pending-wechat-messages.json");
+}
+function readPendingMessages(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        if (!Array.isArray(parsed.messages)) {
+            return [];
+        }
+        return parsed.messages.filter((message) => {
+            return (Boolean(message) &&
+                typeof message === "object" &&
+                typeof message.id === "string" &&
+                typeof message.recipientId === "string" &&
+                typeof message.text === "string" &&
+                typeof message.context === "string" &&
+                typeof message.queuedAt === "string");
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export class PendingWechatMessageStore {
+    filePath;
+    messages;
+    constructor(filePath) {
+        this.filePath = filePath;
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        this.messages = readPendingMessages(filePath);
+    }
+    list() {
+        return this.messages.map((message) => ({ ...message }));
+    }
+    enqueue(recipientId, text, context) {
+        const normalizedRecipientId = recipientId.trim();
+        const normalizedText = text.trim();
+        if (!normalizedRecipientId || !normalizedText) {
+            return null;
+        }
+        const message = {
+            id: crypto.randomUUID(),
+            recipientId: normalizedRecipientId,
+            text: normalizedText,
+            context,
+            queuedAt: new Date().toISOString(),
+        };
+        this.messages.push(message);
+        this.persist();
+        return { ...message };
+    }
+    remove(id) {
+        const next = this.messages.filter((message) => message.id !== id);
+        if (next.length === this.messages.length) {
+            return false;
+        }
+        this.messages = next;
+        this.persist();
+        return true;
+    }
+    persist() {
+        writeJsonFileAtomic(this.filePath, { messages: this.messages });
+    }
+}

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 @@
+export {};

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);
+}