@unlinearity/cli-wechat-bridge 1.1.5 → 1.2.0

package/dist/bridge/wechat-forwarding.js

@@ -1,58 +1,8 @@
-import { truncatePreview } from "./bridge-utils.js";
-import { classifyWechatTransportError, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
-export const WECHAT_SEND_MAX_ATTEMPTS = 3;
-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;
-    }
-}
-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 computeWechatSendRetryDelayMs(attempt) {
-    return WECHAT_SEND_RETRY_BASE_MS * attempt;
-}
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+/** @deprecated Import from ../channels/wechat/wechat-forwarding.ts instead. */
+export * from "../channels/wechat/wechat-forwarding.js";

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

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+/** @deprecated Import from ../channels/wechat/wechat-outbound-queue.ts instead. */
+export * from "../channels/wechat/wechat-outbound-queue.js";

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

@@ -0,0 +1,56 @@
+import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } 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 the reply as a single message, matching the official WeChat bot
+        // client: it posts the full text in one sendmessage call without
+        // chunking. A failed send surfaces through the sender's own retry and
+        // pending-queue handling instead of being split up.
+        const sent = await sender.sendText(visibleText);
+        if (sent === false) {
+            // The send channel is failing (e.g. an expired context token).
+            // Report what was dropped instead of ending silently; this notice
+            // itself is best effort and may also fail.
+            if (parsed.attachments.length > 0) {
+                await sender.sendText(`[bridge] Reply delivery was interrupted; ${parsed.attachments.length} attachment(s) 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,11 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+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-driver.js

@@ -0,0 +1,191 @@
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, isWechatContextUnavailableError, } from "../../channels/wechat/wechat-forwarding.js";
+import { describeWechatTransportError, isWechatContextTokenStaleError, } from "../../wechat/wechat-transport.js";
+import { formatDuration } from "../../core/text-utils.js";
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Per-recipient typing tickets with a random-refresh TTL and retry backoff. */
+class TypingTicketCache {
+    fetchTicket;
+    log;
+    ttlMs;
+    initialRetryMs;
+    maxRetryMs;
+    cache = new Map();
+    constructor(fetchTicket, log, ttlMs = 24 * 60 * 60 * 1000, initialRetryMs = 2_000, maxRetryMs = 60 * 60 * 1000) {
+        this.fetchTicket = fetchTicket;
+        this.log = log;
+        this.ttlMs = ttlMs;
+        this.initialRetryMs = initialRetryMs;
+        this.maxRetryMs = maxRetryMs;
+    }
+    async getFor(recipientId) {
+        const now = Date.now();
+        const entry = this.cache.get(recipientId);
+        if (entry && now < entry.nextFetchAt) {
+            return entry.ticket;
+        }
+        let ticket;
+        try {
+            ticket = await this.fetchTicket(recipientId);
+        }
+        catch {
+            ticket = "";
+        }
+        if (ticket) {
+            this.cache.set(recipientId, {
+                ticket,
+                nextFetchAt: now + Math.random() * this.ttlMs,
+                retryDelayMs: this.initialRetryMs,
+            });
+            this.log(`wechat_typing_ticket_${entry ? "refreshed" : "cached"}: recipient=${recipientId}`);
+        }
+        else {
+            const retryDelayMs = Math.min((entry?.retryDelayMs ?? this.initialRetryMs / 2) * 2, this.maxRetryMs);
+            this.cache.set(recipientId, {
+                ticket: entry?.ticket ?? "",
+                nextFetchAt: now + retryDelayMs,
+                retryDelayMs,
+            });
+            this.log(`wechat_typing_ticket_fetch_failed: recipient=${recipientId} retry_in=${formatDuration(retryDelayMs)}`);
+        }
+        return this.cache.get(recipientId)?.ticket ?? "";
+    }
+    /** Cached ticket without triggering a fetch (for cancel sends). */
+    peekCached(recipientId) {
+        return this.cache.get(recipientId)?.ticket ?? "";
+    }
+}
+const WECHAT_CONTEXT_STALE_HINT = "WeChat conversation context is stale or unavailable. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
+/** ChannelDriver over the WeChat iLink long-poll transport. */
+export class WechatChannelDriver {
+    id = "wechat";
+    displayName = "WeChat";
+    operatorDescription = "the configured WeChat owner";
+    capabilities = {
+        streamingReplies: false,
+        outboundAttachments: false,
+        multiConversation: false,
+        pushInbound: false,
+    };
+    transport;
+    logError;
+    buildInboundPromptImpl;
+    typingKeepaliveMs;
+    typingTickets;
+    typingTimers = new Map();
+    constructor(options) {
+        this.transport = options.transport;
+        this.logError = options.logError;
+        this.buildInboundPromptImpl = options.buildInboundPrompt;
+        this.typingKeepaliveMs = options.typingKeepaliveMs ?? 5_000;
+        this.typingTickets = new TypingTicketCache((recipientId) => this.transport.fetchTypingTicket(recipientId), (message) => this.logError(`[typing] ${message}`));
+    }
+    defaultConversation() {
+        return null;
+    }
+    directConversation(senderId) {
+        return {
+            channelId: "wechat",
+            conversationId: senderId,
+            recipientId: senderId,
+        };
+    }
+    async sendText(params) {
+        const { target, text, context, log } = params;
+        const senderId = target.recipientId;
+        const startedAtMs = Date.now();
+        log(`wechat_send_started: context=${context} recipient=${senderId} chars=${Array.from(text).length}`);
+        for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
+            try {
+                await this.transport.sendText(senderId, text);
+                log(`wechat_send_completed: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
+                return { status: "sent" };
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    log(`wechat_send_timeout: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
+                }
+                if (isWechatContextUnavailableError(err)) {
+                    if (isWechatContextTokenStaleError(err)) {
+                        this.transport.clearCachedContextToken(senderId);
+                    }
+                    this.logError(`Failed to send WeChat ${context}: ${WECHAT_CONTEXT_STALE_HINT}`);
+                    log(isWechatContextTokenStaleError(err)
+                        ? formatWechatContextTokenStaleLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error: err,
+                        })
+                        : formatWechatSendFailureLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error: err,
+                        }));
+                    return {
+                        status: "target_stale",
+                        error: err,
+                        target,
+                    };
+                }
+                if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
+                    const delayMs = computeWechatSendRetryDelayMs(attempt);
+                    this.logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
+                    log(formatWechatSendRetryLogEntry({
+                        context,
+                        recipientId: senderId,
+                        attempt,
+                        delayMs,
+                        error: err,
+                    }));
+                    await delay(delayMs);
+                    continue;
+                }
+                this.logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
+                log(formatWechatSendFailureLogEntry({
+                    context,
+                    recipientId: senderId,
+                    error: err,
+                }));
+                return { status: "failed", error: err, target };
+            }
+        }
+        return { status: "failed", error: new Error("unreachable"), target };
+    }
+    buildInboundPrompt(text, attachments) {
+        return this.buildInboundPromptImpl(text, attachments);
+    }
+    async beginTyping(recipientId) {
+        if (this.typingTimers.has(recipientId)) {
+            return;
+        }
+        const ticket = await this.typingTickets.getFor(recipientId);
+        if (!ticket) {
+            return;
+        }
+        const sent = await this.transport.sendTyping(recipientId, ticket, 1);
+        if (!sent) {
+            return;
+        }
+        const timer = setInterval(() => {
+            void this.transport.sendTyping(recipientId, ticket, 1);
+        }, this.typingKeepaliveMs);
+        timer.unref?.();
+        this.typingTimers.set(recipientId, timer);
+    }
+    async endTyping(recipientId) {
+        const timer = this.typingTimers.get(recipientId);
+        if (timer) {
+            clearInterval(timer);
+            this.typingTimers.delete(recipientId);
+        }
+        const ticket = this.typingTickets.peekCached(recipientId);
+        if (!ticket) {
+            return;
+        }
+        await this.transport.sendTyping(recipientId, ticket, 2);
+    }
+    async endAllTyping() {
+        for (const recipientId of [...this.typingTimers.keys()]) {
+            await this.endTyping(recipientId);
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+import { truncatePreview } from "../../bridge/bridge-utils.js";
+import { classifyWechatTransportError, describeWechatTransportError, isWechatContextTokenStaleError, } from "../../wechat/wechat-transport.js";
+export const WECHAT_SEND_CONTEXTS = [
+    "final_reply",
+    "message",
+    "notice",
+    "approval_required",
+    "user_input_required",
+    "mirrored_user_input",
+    "session_switched",
+    "thread_switched",
+    "task_failed",
+    "fatal_error",
+    "inbound_error",
+    "thinking",
+];
+export function isWechatSendContext(value) {
+    return typeof value === "string" &&
+        WECHAT_SEND_CONTEXTS.includes(value);
+}
+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,118 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+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";
+/** Contexts worth redelivering after the channel recovers. */
+const PENDING_WORTHY_CONTEXTS = new Set([
+    "final_reply",
+    "approval_required",
+    "user_input_required",
+    "task_failed",
+    "fatal_error",
+]);
+/** Drop queued messages older than this — stale replies are noise, not value. */
+const PENDING_MAX_AGE_MS = 30 * 60 * 1000;
+/** Cap the backlog so one recovery never floods the chat. */
+const PENDING_MAX_MESSAGES = 10;
+function isExpired(message, now = Date.now()) {
+    const queuedAtMs = Date.parse(message.queuedAt);
+    if (!Number.isFinite(queuedAtMs)) {
+        return true;
+    }
+    return now - queuedAtMs > PENDING_MAX_AGE_MS;
+}
+export function getPendingWechatMessagesFile(cwd) {
+    return getPendingChannelMessagesFile(cwd, "wechat");
+}
+export function getPendingChannelMessagesFile(cwd, channelId) {
+    return path.join(getWorkspaceChannelPaths(cwd).workspaceDir, `pending-${channelId}-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() {
+        this.compact();
+        return this.messages.map((message) => ({
+            ...message,
+            target: message.target ? { ...message.target } : undefined,
+        }));
+    }
+    enqueue(recipientId, text, context, target) {
+        const normalizedRecipientId = recipientId.trim();
+        const normalizedText = text.trim();
+        if (!normalizedRecipientId || !normalizedText) {
+            return null;
+        }
+        if (!PENDING_WORTHY_CONTEXTS.has(context)) {
+            return null;
+        }
+        const message = {
+            id: crypto.randomUUID(),
+            recipientId: normalizedRecipientId,
+            text: normalizedText,
+            context,
+            queuedAt: new Date().toISOString(),
+            target: target ? { ...target } : undefined,
+        };
+        this.messages.push(message);
+        this.compact();
+        this.persist();
+        return { ...message };
+    }
+    /** Drop expired entries and trim the backlog to the cap (oldest first). */
+    compact() {
+        const now = Date.now();
+        const fresh = this.messages.filter((message) => !isExpired(message, now));
+        while (fresh.length > PENDING_MAX_MESSAGES) {
+            fresh.shift();
+        }
+        this.messages = fresh;
+    }
+    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 });
+    }
+}