@seawork/server 1.0.22 → 2.0.2-rc.6

package/dist/server/server/integrations/wecom-openclaw/bridge.js

@@ -0,0 +1,1229 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { generateReqId, MessageType, WSAuthFailureError, WSClient, WSReconnectExhaustedError, } from "@wecom/aibot-node-sdk";
+import { DEFAULT_AGENT_PROVIDER, getAgentProviderDefinition, isValidAgentProvider, } from "../../agent/provider-manifest.js";
+import { defaultWeComOpenClawWorkspace, resolveWeComOpenClawAgentCwd } from "./workspace.js";
+const DEFAULT_WEBSOCKET_URL = "wss://openws.work.weixin.qq.com";
+const OPENCLAW_SCENE = 1;
+const OPENCLAW_PLUGIN_VERSION = "2026.5.25";
+const MAX_MARKDOWN_BYTES = 18000;
+const MAX_STREAM_BYTES = MAX_MARKDOWN_BYTES;
+const DEFAULT_STREAM_UPDATE_INTERVAL_MS = 1000;
+const DEFAULT_LOADING_TICK_INTERVAL_MS = 3000;
+const STREAM_TRUNCATION_SUFFIX = "\n\n...（内容过长，已截断）";
+const DEFAULT_CONVERSATION_IDLE_TTL_MS = 30 * 60 * 1000;
+const DEFAULT_MAX_CONVERSATIONS = 200;
+const LOADING_ELLIPSIS_FRAMES = ["…", "……", "………"];
+const DEFAULT_MAX_INBOUND_MEDIA_BYTES = 10 * 1024 * 1024;
+const DEFAULT_MEDIA_DOWNLOAD_TIMEOUT_MS = 20000;
+const DEFAULT_MEDIA_AGGREGATE_WINDOW_MS = 1500;
+// Providers whose AgentPromptInput accepts image content blocks. seaagent and
+// deepseek throw on image blocks, so the bridge must downgrade to text for them.
+const IMAGE_CAPABLE_PROVIDERS = new Set(["codex", "claude"]);
+const MEDIA_DIRECTIVE_PATTERN = /^(MEDIA|FILE):(.+)$/;
+export class WeComOpenClawBridge {
+    constructor(options) {
+        this.conversations = new Map();
+        this.wsClient = null;
+        this.stopped = false;
+        this.agentManager = options.agentManager;
+        this.config = options.config;
+        this.loadAgent = options.loadAgent ?? null;
+        this.allowFirstUser = options.allowFirstUser ?? null;
+        this.now = options.now ?? Date.now;
+        this.conversationIdleTtlMs = options.conversationIdleTtlMs ?? DEFAULT_CONVERSATION_IDLE_TTL_MS;
+        this.maxConversations = Math.max(1, options.maxConversations ?? DEFAULT_MAX_CONVERSATIONS);
+        this.streamUpdateIntervalMs = Math.max(0, options.streamUpdateIntervalMs ?? DEFAULT_STREAM_UPDATE_INTERVAL_MS);
+        this.loadingTickIntervalMs = Math.max(1, options.loadingTickIntervalMs ?? DEFAULT_LOADING_TICK_INTERVAL_MS);
+        this.logger = options.logger.child({
+            module: "integrations",
+            integration: "wecom-openclaw",
+        });
+    }
+    updateConfig(patch) {
+        const previousConnectionKey = buildConnectionKey(this.config);
+        this.config = {
+            ...this.config,
+            ...patch,
+        };
+        const nextConnectionKey = buildConnectionKey(this.config);
+        if (this.stopped) {
+            return;
+        }
+        if (!this.config.enabled) {
+            this.wsClient?.disconnect();
+            this.wsClient = null;
+            return;
+        }
+        if (this.wsClient && previousConnectionKey === nextConnectionKey) {
+            return;
+        }
+        this.wsClient?.disconnect();
+        this.wsClient = null;
+        this.start();
+    }
+    start() {
+        if (!this.config.enabled) {
+            return;
+        }
+        if (!this.config.botId || !this.config.secret) {
+            this.logger.warn("OpenClaw WeCom bridge enabled without botId/secret; skipping startup");
+            return;
+        }
+        if (!hasExplicitAllowlist(this.config) && !this.config.pendingAllowFirstUser) {
+            this.logger.warn("OpenClaw WeCom bridge enabled without allowUsers/allowChats; skipping startup");
+            return;
+        }
+        if (this.wsClient) {
+            return;
+        }
+        const wsClient = new WSClient({
+            botId: this.config.botId,
+            secret: this.config.secret,
+            wsUrl: this.config.websocketUrl ?? DEFAULT_WEBSOCKET_URL,
+            heartbeatInterval: 30000,
+            maxReconnectAttempts: 10,
+            maxAuthFailureAttempts: 5,
+            scene: OPENCLAW_SCENE,
+            plug_version: this.config.pluginVersion ?? OPENCLAW_PLUGIN_VERSION,
+            logger: {
+                debug: (message, ...args) => this.logger.debug({ args }, message),
+                info: (message, ...args) => this.logger.info({ args }, message),
+                warn: (message, ...args) => this.logger.warn({ args }, message),
+                error: (message, ...args) => this.logger.error({ args }, message),
+            },
+        });
+        wsClient.on("connected", () => {
+            this.logger.info("OpenClaw WeCom WebSocket connected");
+        });
+        wsClient.on("authenticated", () => {
+            this.logger.info("OpenClaw WeCom WebSocket authenticated");
+        });
+        wsClient.on("disconnected", (reason) => {
+            this.logger.warn({ reason }, "OpenClaw WeCom WebSocket disconnected");
+        });
+        wsClient.on("reconnecting", (attempt) => {
+            this.logger.warn({ attempt }, "OpenClaw WeCom WebSocket reconnecting");
+        });
+        wsClient.on("event.disconnected_event", (frame) => {
+            this.logger.error({ reqId: frame.headers.req_id }, "OpenClaw WeCom WebSocket was kicked by another connection");
+            wsClient.disconnect();
+        });
+        wsClient.on("event.enter_chat", (frame) => {
+            void this.replyWelcome(frame);
+        });
+        wsClient.on("error", (error) => {
+            this.logger.error({ err: error }, "OpenClaw WeCom WebSocket error");
+            if (error instanceof WSAuthFailureError || error instanceof WSReconnectExhaustedError) {
+                wsClient.disconnect();
+            }
+        });
+        wsClient.on("message", (frame) => {
+            void this.enqueueMessage(frame);
+        });
+        this.wsClient = wsClient;
+        wsClient.connect();
+    }
+    stop() {
+        this.stopped = true;
+        this.wsClient?.disconnect();
+        this.wsClient = null;
+    }
+    async replyWelcome(frame) {
+        if (!this.wsClient || this.stopped) {
+            return;
+        }
+        try {
+            await this.wsClient.replyWelcome(frame, {
+                msgtype: "text",
+                text: {
+                    content: "已连接 Seawork。直接发送任务即可。",
+                },
+            });
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to send OpenClaw WeCom welcome reply");
+        }
+    }
+    async enqueueMessage(frame) {
+        if (this.stopped) {
+            return;
+        }
+        const inbound = this.parseInboundMessage(frame);
+        if (!inbound) {
+            return;
+        }
+        if (!this.isAllowed(inbound) && !(await this.allowPendingFirstUser(inbound))) {
+            this.logger.warn({
+                chatId: inbound.chatId,
+                chatType: inbound.chatType,
+                senderId: inbound.senderId,
+            }, "Rejected OpenClaw WeCom message by allowlist");
+            return;
+        }
+        const key = this.conversationKey(inbound);
+        if (this.bufferAttachmentOnly(key, inbound)) {
+            return;
+        }
+        this.mergeBufferedAttachments(key, inbound);
+        const now = this.now();
+        this.pruneConversations(now);
+        let existing = this.conversations.get(key);
+        if (!existing && this.conversations.size >= this.maxConversations) {
+            this.evictOldestIdleConversation();
+            existing = this.conversations.get(key);
+            if (!existing && this.conversations.size >= this.maxConversations) {
+                this.logger.warn({ maxConversations: this.maxConversations }, "Rejected OpenClaw WeCom message because conversation cache is full");
+                return;
+            }
+        }
+        const pending = (existing?.pending ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(() => this.handleMessage(key, inbound))
+            .finally(() => this.markConversationIdle(key, pending));
+        this.conversations.set(key, {
+            agentId: existing?.agentId ?? "",
+            pending,
+            lastActivityAt: now,
+            active: true,
+        });
+    }
+    parseInboundMessage(frame) {
+        const body = frame.body;
+        if (!body?.from?.userid || !body.msgid) {
+            return null;
+        }
+        const chatId = body.chatid || body.from.userid;
+        const chatType = body.chattype === "group" ? "group" : "single";
+        const text = extractText(body).trim();
+        const attachments = extractAttachments(body);
+        if (!text && attachments.length === 0) {
+            return null;
+        }
+        return {
+            frame,
+            chatId,
+            chatType,
+            senderId: body.from.userid,
+            text,
+            attachments,
+            receivedAt: this.now(),
+        };
+    }
+    isAllowed(message) {
+        const allowUsers = normalizeAllowlist(this.config.allowUsers);
+        const allowChats = normalizeAllowlist(this.config.allowChats);
+        if (allowUsers.size === 0 && allowChats.size === 0) {
+            return false;
+        }
+        if (allowUsers.has("*") || allowUsers.has(message.senderId)) {
+            return true;
+        }
+        if (allowChats.has("*") || allowChats.has(message.chatId)) {
+            return true;
+        }
+        return false;
+    }
+    async allowPendingFirstUser(message) {
+        if (!this.config.pendingAllowFirstUser || !this.allowFirstUser) {
+            return false;
+        }
+        if (message.chatType !== "single" || message.chatId !== message.senderId) {
+            return false;
+        }
+        const consumed = await this.allowFirstUser(message.senderId);
+        if (!consumed) {
+            this.config.pendingAllowFirstUser = false;
+            this.logger.warn({ senderId: message.senderId }, "Rejected OpenClaw WeCom first-user binding because it was already consumed");
+            return false;
+        }
+        this.config.allowUsers = mergeAllowlist(this.config.allowUsers, [message.senderId]);
+        this.config.pendingAllowFirstUser = false;
+        this.logger.info({ senderId: message.senderId }, "Allowed first OpenClaw WeCom user");
+        return true;
+    }
+    conversationKey(message) {
+        return `${message.chatType}:${message.chatId}`;
+    }
+    // Hold an attachment-only single-chat message briefly so a follow-up text can
+    // be merged ("screenshot + text" split into two WeCom messages). Returns true
+    // when the message was buffered (caller must stop processing it now).
+    bufferAttachmentOnly(key, message) {
+        const windowMs = this.mediaAggregateWindowMs();
+        if (windowMs <= 0 || message.chatType !== "single") {
+            return false;
+        }
+        if (message.text || message.attachments.length === 0) {
+            return false;
+        }
+        const state = this.ensureConversation(key);
+        const existing = state.pendingAttachments;
+        // Only coalesce buffers from the same sender; never let a different user's
+        // attachments bleed into this turn.
+        const prior = existing && existing.senderId === message.senderId ? existing.attachments : [];
+        if (existing?.timer) {
+            clearTimeout(existing.timer);
+        }
+        const attachments = [...prior, ...message.attachments];
+        const flushMessage = { ...message, attachments };
+        const timer = setTimeout(() => {
+            this.flushPendingAttachments(key, flushMessage);
+        }, windowMs);
+        timer.unref?.();
+        state.pendingAttachments = {
+            senderId: message.senderId,
+            attachments,
+            timer,
+        };
+        state.lastActivityAt = this.now();
+        return true;
+    }
+    mergeBufferedAttachments(key, message) {
+        const state = this.conversations.get(key);
+        const buffer = state?.pendingAttachments;
+        if (!state || !buffer) {
+            return;
+        }
+        // Same-sender guard: only a follow-up from the same user absorbs the
+        // buffered attachments. A different sender leaves the buffer (and its timer)
+        // untouched so it still flushes on its own turn.
+        if (buffer.senderId !== message.senderId) {
+            return;
+        }
+        if (buffer.timer) {
+            clearTimeout(buffer.timer);
+        }
+        state.pendingAttachments = undefined;
+        // Always merge once we own the buffer — even if the window just lapsed
+        // before the flush timer fired. Dropping here would silently swallow the
+        // user's earlier attachment (it would be neither sent on its own nor merged).
+        message.attachments = [...buffer.attachments, ...message.attachments];
+    }
+    // Timer callback: the buffered attachment-only message timed out without a
+    // follow-up text, so process it on its own.
+    flushPendingAttachments(key, message) {
+        if (this.stopped) {
+            return;
+        }
+        const state = this.conversations.get(key);
+        if (!state?.pendingAttachments) {
+            return;
+        }
+        state.pendingAttachments = undefined;
+        const pending = state.pending
+            .catch(() => undefined)
+            .then(() => this.handleMessage(key, message))
+            .finally(() => this.markConversationIdle(key, pending));
+        state.pending = pending;
+        state.active = true;
+        state.lastActivityAt = this.now();
+    }
+    ensureConversation(key) {
+        let state = this.conversations.get(key);
+        if (!state) {
+            state = {
+                agentId: "",
+                pending: Promise.resolve(),
+                lastActivityAt: this.now(),
+                active: false,
+            };
+            this.conversations.set(key, state);
+        }
+        return state;
+    }
+    async handleMessage(key, message) {
+        const wsClient = this.wsClient;
+        if (!wsClient || this.stopped) {
+            return;
+        }
+        const streamId = generateReqId("stream");
+        let agentId = this.resolveConfiguredAgentId();
+        try {
+            await this.replyStream({
+                message,
+                streamId,
+                agentId,
+                content: formatProcessingReply(agentId),
+                finish: false,
+            });
+            if (!agentId) {
+                agentId = this.conversations.get(key)?.agentId ?? null;
+            }
+            if (!agentId || !this.agentManager.getAgent(agentId)) {
+                const agent = agentId
+                    ? await this.loadConversationAgent(agentId)
+                    : await this.createConversationAgent(message);
+                agentId = agent.id;
+                this.updateConversationAgent(key, agentId);
+            }
+            const prompt = await this.buildPromptInput(message);
+            this.agentManager.recordUserMessage(agentId, prompt.recordText, {
+                messageId: message.frame.body?.msgid,
+                emitState: false,
+                ...(prompt.images.length > 0 ? { images: prompt.images } : {}),
+            });
+            await this.streamAgentReply(agentId, message, streamId, prompt.input);
+        }
+        catch (error) {
+            this.logger.error({ err: error, agentId }, "Failed to process OpenClaw WeCom message");
+            await this.replyStream({
+                message,
+                streamId,
+                agentId,
+                content: `Seawork 处理失败：${formatError(error)}`,
+                finish: true,
+                fallbackToMarkdown: true,
+            });
+        }
+    }
+    async streamAgentReply(agentId, message, streamId, prompt) {
+        let assistantText = "";
+        let statusText = null;
+        let loadingTick = 0;
+        let lastSentContent = formatProcessingReply(agentId);
+        let lastSentAt = this.now();
+        const sendIntermediate = async (force = false) => {
+            const content = formatStreamingReply(agentId, assistantText, statusText, loadingTick);
+            if (!content || content === lastSentContent) {
+                return;
+            }
+            const now = this.now();
+            if (!force && now - lastSentAt < this.streamUpdateIntervalMs) {
+                return;
+            }
+            const sent = await this.replyStream({
+                message,
+                streamId,
+                agentId,
+                content,
+                finish: false,
+            });
+            if (sent) {
+                lastSentContent = content;
+                lastSentAt = now;
+            }
+        };
+        const sendStatus = async (nextStatus) => {
+            if (statusText === nextStatus) {
+                return;
+            }
+            statusText = nextStatus;
+            loadingTick = 0;
+            await sendIntermediate(true);
+        };
+        const sendLoadingTick = async () => {
+            if (assistantText.trim() && !statusText) {
+                return;
+            }
+            loadingTick += 1;
+            await sendIntermediate(true);
+        };
+        const sendFinal = async (content, withMedia = false) => {
+            const media = withMedia
+                ? this.extractMediaDirectives(content)
+                : { cleanedText: content, directives: [] };
+            // Media-only reply (agent emitted just MEDIA:/FILE: directives, so
+            // cleanedText is empty): send media FIRST, then derive an honest final
+            // text from the real send result — a placeholder only after media
+            // actually went out, otherwise a failure note. This avoids closing the
+            // stream with a blank bubble or a premature "media generated" claim.
+            if (!media.cleanedText && media.directives.length > 0) {
+                const result = await this.sendMediaDirectives(message, media.directives);
+                const finalText = result.sent > 0
+                    ? "已生成媒体内容。"
+                    : result.failures.length > 0
+                        ? formatFailureSummary(result.failures)
+                        : // Output disabled (no allowlist): media was stripped and nothing
+                            // sent. Never close the stream with an empty bubble.
+                            "本轮没有可显示的文本内容。";
+                await this.replyStream({
+                    message,
+                    streamId,
+                    agentId,
+                    content: finalText,
+                    finish: true,
+                    fallbackToMarkdown: true,
+                });
+                return;
+            }
+            // Reply has visible text: send it FIRST so a media failure never blocks
+            // the user from seeing the textual answer, then stream media on the side.
+            await this.replyStream({
+                message,
+                streamId,
+                agentId,
+                content: media.cleanedText,
+                finish: true,
+                fallbackToMarkdown: true,
+            });
+            const { failures } = await this.sendMediaDirectives(message, media.directives);
+            if (failures.length > 0) {
+                await this.sendMarkdownFallback(message.chatId, formatFailureSummary(failures));
+            }
+        };
+        const stream = this.agentManager.streamAgent(agentId, prompt);
+        const iterator = stream[Symbol.asyncIterator]();
+        let pendingNext = iterator.next();
+        try {
+            while (true) {
+                const next = await Promise.race([
+                    pendingNext.then((result) => ({ type: "event", result })),
+                    sleep(this.loadingTickIntervalMs).then(() => ({ type: "loading_tick" })),
+                ]);
+                if (next.type === "loading_tick") {
+                    await sendLoadingTick();
+                    continue;
+                }
+                const { value: event, done } = next.result;
+                if (done) {
+                    break;
+                }
+                if (event.type === "timeline") {
+                    if (event.item.type === "assistant_message") {
+                        assistantText += event.item.text;
+                        const hadStatus = statusText !== null;
+                        statusText = null;
+                        loadingTick = 0;
+                        await sendIntermediate(hadStatus);
+                    }
+                    else {
+                        const nextStatus = formatTimelineStatus(event.item);
+                        if (nextStatus) {
+                            await sendStatus(nextStatus);
+                        }
+                    }
+                }
+                else if (event.type === "turn_completed") {
+                    await sendFinal(formatFinalReply(agentId, assistantText), true);
+                    return;
+                }
+                else if (event.type === "turn_failed") {
+                    await sendFinal(`Seawork 处理失败：${formatTurnFailedEvent(event)}`);
+                    return;
+                }
+                else if (event.type === "turn_canceled") {
+                    await sendFinal(formatTurnCanceledEvent(event));
+                    return;
+                }
+                pendingNext = iterator.next();
+            }
+        }
+        finally {
+            await iterator.return?.(undefined);
+        }
+        await sendFinal(formatFinalReply(agentId, assistantText), true);
+    }
+    resolveConfiguredAgentId() {
+        if (this.config.agentMode !== "existing") {
+            return null;
+        }
+        const agentId = this.config.agentId?.trim();
+        if (!agentId) {
+            return null;
+        }
+        return agentId;
+    }
+    async loadConversationAgent(agentId) {
+        const existing = this.agentManager.getAgent(agentId);
+        if (existing) {
+            return existing;
+        }
+        if (this.loadAgent) {
+            return this.loadAgent(agentId);
+        }
+        throw new Error(`Configured WeCom agent is not loaded: ${agentId}`);
+    }
+    async createConversationAgent(message) {
+        const normalized = normalizeWeComAgentConfig({
+            provider: this.config.provider,
+            modeId: this.config.modeId,
+            model: this.config.model,
+            thinkingOptionId: this.config.thinkingOptionId,
+        });
+        const provider = normalized.provider;
+        const seaworkHome = this.config.seaworkHome ?? path.join(os.homedir(), ".seawork");
+        const cwd = resolveWeComOpenClawAgentCwd(this.config.cwd, seaworkHome);
+        if (cwd === defaultWeComOpenClawWorkspace()) {
+            await mkdir(cwd, { recursive: true });
+        }
+        return this.agentManager.createAgent({
+            provider,
+            cwd,
+            ...(normalized.modeId ? { modeId: normalized.modeId } : {}),
+            ...(normalized.model ? { model: normalized.model } : {}),
+            ...(normalized.thinkingOptionId ? { thinkingOptionId: normalized.thinkingOptionId } : {}),
+            title: `WeCom ${message.chatType}:${message.chatId}`,
+            systemPrompt: [
+                "你正在通过企业微信智能机器人接收用户请求。",
+                "这条链路复用 OpenClaw 官方企业微信智能机器人协议。",
+                "回复要适合直接发送到企业微信，优先使用简洁的中文 Markdown。",
+            ].join("\n"),
+        }, undefined, {
+            labels: {
+                "seawork.created-by": "wecom-openclaw",
+                "wecom.openclaw.chat-id": message.chatId,
+                "wecom.openclaw.chat-type": message.chatType,
+                "wecom.openclaw.sender-id": message.senderId,
+            },
+        });
+    }
+    maxInboundMediaBytes() {
+        return Math.max(0, this.config.maxInboundMediaBytes ?? DEFAULT_MAX_INBOUND_MEDIA_BYTES);
+    }
+    mediaDownloadTimeoutMs() {
+        return Math.max(0, this.config.mediaDownloadTimeoutMs ?? DEFAULT_MEDIA_DOWNLOAD_TIMEOUT_MS);
+    }
+    mediaAggregateWindowMs() {
+        return Math.max(0, this.config.mediaAggregateWindowMs ?? DEFAULT_MEDIA_AGGREGATE_WINDOW_MS);
+    }
+    mediaOutputAllowedRoots() {
+        return (this.config.mediaOutputAllowedRoots ?? [])
+            .map((root) => root.trim())
+            .filter(Boolean)
+            .map((root) => path.resolve(root));
+    }
+    // Build the agent prompt from inbound text + image attachments. Images are
+    // always downloaded so the timeline can persist and render inbound thumbnails.
+    // Only image-capable providers receive image content blocks; everything else
+    // (non-image files, unsupported providers, download failures) is summarized
+    // into the text so the agent still has context.
+    async buildPromptInput(message) {
+        const provider = this.config.provider ?? DEFAULT_AGENT_PROVIDER;
+        const supportsImages = IMAGE_CAPABLE_PROVIDERS.has(provider);
+        const notes = [];
+        const imageBlocks = [];
+        const recordedImages = [];
+        const images = message.attachments.filter((att) => att.kind === "image");
+        const files = message.attachments.filter((att) => att.kind === "file");
+        if (files.length > 0) {
+            notes.push(`（收到 ${files.length} 个文件附件，当前链路暂不解析文件内容，已忽略）`);
+        }
+        for (const image of images) {
+            const downloaded = await this.downloadImageBlock(image);
+            if (!downloaded.buffer) {
+                notes.push(`（一张图片${IMAGE_FAILURE_REASONS[downloaded.reason]}，已忽略）`);
+                continue;
+            }
+            if (supportsImages) {
+                imageBlocks.push({
+                    type: "image",
+                    data: downloaded.buffer.toString("base64"),
+                    mimeType: downloaded.mimeType,
+                });
+            }
+            // Persist for UI rendering even when the provider cannot consume image
+            // blocks. A persist failure only loses the thumbnail; the agent still gets
+            // either the structured image block or the text summary below.
+            const persisted = await this.persistInboundImage(downloaded.buffer, downloaded.mimeType, downloaded.filename);
+            if (persisted) {
+                recordedImages.push(persisted.metadata);
+            }
+        }
+        if (images.length > 0 && !supportsImages) {
+            notes.push(`（收到 ${images.length} 张图片，当前 provider「${provider}」不支持图片输入）`);
+        }
+        // The text recorded on the timeline and sent to the agent stays identical.
+        // Persisted image metadata is attached separately on the user_message, so no
+        // host file path ever needs to appear in the prompt text.
+        const agentText = [message.text, ...notes]
+            .filter((part) => part.trim())
+            .join("\n\n")
+            .trim();
+        const recordText = agentText || (images.length > 0 ? "[图片]" : "");
+        if (imageBlocks.length === 0) {
+            // Keep the original string path so providers without structured input and
+            // existing behavior are untouched.
+            return { input: agentText, recordText, images: recordedImages };
+        }
+        const blocks = [];
+        if (agentText) {
+            blocks.push({ type: "text", text: agentText });
+        }
+        blocks.push(...imageBlocks);
+        return { input: blocks, recordText, images: recordedImages };
+    }
+    async downloadImageBlock(attachment) {
+        const wsClient = this.wsClient;
+        if (!wsClient) {
+            return { buffer: null, reason: "error" };
+        }
+        try {
+            const timeoutMs = this.mediaDownloadTimeoutMs();
+            const download = wsClient.downloadFile(attachment.url, attachment.aesKey);
+            const result = timeoutMs > 0 ? await withTimeout(download, timeoutMs) : await download;
+            if (result.buffer.length > this.maxInboundMediaBytes()) {
+                this.logger.warn({ bytes: result.buffer.length, limit: this.maxInboundMediaBytes() }, "Dropped oversized OpenClaw WeCom inbound image");
+                return { buffer: null, reason: "oversize" };
+            }
+            return {
+                buffer: result.buffer,
+                mimeType: guessImageMimeType(result.filename),
+                filename: result.filename,
+                reason: null,
+            };
+        }
+        catch (error) {
+            const timedOut = error instanceof Error && error.message.includes("timed out");
+            this.logger.warn({ err: error }, "Failed to download OpenClaw WeCom inbound image");
+            return { buffer: null, reason: timedOut ? "timeout" : "error" };
+        }
+    }
+    // Persist an inbound image into the desktop-managed attachment dir so the
+    // desktop UI can render it. The desktop main process only serves previews for
+    // files under `$SEAWORK_HOME/desktop-attachments/`. The metadata's storageKey
+    // is the bare filename (opaque id) — NOT the absolute path — so the daemon's
+    // host filesystem layout never leaks to timeline subscribers; the desktop
+    // resolves the filename against its own managed dir. Returns null on write
+    // failure — the agent still receives the image block regardless.
+    async persistInboundImage(buffer, mimeType, filename) {
+        const seaworkHome = this.config.seaworkHome ?? path.join(os.homedir(), ".seawork");
+        const dir = path.join(seaworkHome, "desktop-attachments");
+        const id = randomUUID();
+        const ext = mimeExtension(mimeType);
+        const storedName = `${id}${ext}`;
+        const filePath = path.join(dir, storedName);
+        try {
+            await mkdir(dir, { recursive: true });
+            await writeFile(filePath, buffer);
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to persist OpenClaw WeCom inbound image");
+            return null;
+        }
+        return {
+            metadata: {
+                id,
+                mimeType,
+                storageType: "desktop-file",
+                // Opaque id (filename only) — desktop resolves it locally.
+                storageKey: storedName,
+                fileName: filename ?? null,
+                byteSize: buffer.length,
+                createdAt: this.now(),
+            },
+        };
+    }
+    extractMediaDirectives(text) {
+        const allowedRoots = this.mediaOutputAllowedRoots();
+        const directives = [];
+        const keptLines = [];
+        for (const line of text.split("\n")) {
+            const match = MEDIA_DIRECTIVE_PATTERN.exec(line.trim());
+            if (!match) {
+                keptLines.push(line);
+                continue;
+            }
+            // Always strip directive lines — even when output is disabled — so a raw
+            // host path can never leak into the visible WeCom reply.
+            const directive = match[1];
+            const filePath = match[2].trim();
+            // Only accept absolute paths: a relative path would resolve against the
+            // daemon's (unstable) cwd, making allowlist matching nondeterministic.
+            const allowed = allowedRoots.length > 0 &&
+                path.isAbsolute(filePath) &&
+                isPathWithinRoots(filePath, allowedRoots);
+            directives.push({
+                kind: directive === "MEDIA" ? "image" : "file",
+                path: filePath,
+                allowed,
+            });
+        }
+        return { cleanedText: keptLines.join("\n").trim(), directives };
+    }
+    // Upload + reply each allowed media directive. Returns human-readable failure
+    // summaries (path not allowlisted, file missing, upload error). When output is
+    // globally disabled (no allowlist configured), directives are silently
+    // ignored — the lines were already stripped from the visible text.
+    async sendMediaDirectives(message, directives) {
+        const allowedRoots = this.mediaOutputAllowedRoots();
+        if (allowedRoots.length === 0) {
+            return { sent: 0, failures: [] };
+        }
+        const failures = [];
+        let sent = 0;
+        const wsClient = this.wsClient;
+        for (const directive of directives) {
+            // Only ever expose the basename to the remote user; the full host path is
+            // kept to the server log to avoid leaking the local filesystem layout.
+            const name = path.basename(directive.path);
+            if (!directive.allowed) {
+                failures.push(`${name}（路径不在允许的目录内，已拒绝）`);
+                continue;
+            }
+            // Resolve symlinks before the final boundary check: a symlink living
+            // inside an allowlisted root must not be able to point at a file outside
+            // it. The sync resolve()/relative() check above can't see through links.
+            const realPath = await this.resolveAllowedRealPath(directive.path, allowedRoots);
+            if (!realPath) {
+                failures.push(`${name}（路径不在允许的目录内，已拒绝）`);
+                continue;
+            }
+            if (!wsClient?.isConnected) {
+                failures.push(`${name}（连接已断开，未发送）`);
+                continue;
+            }
+            try {
+                const buffer = await readFile(realPath);
+                const mediaType = directive.kind;
+                const uploaded = await wsClient.uploadMedia(buffer, {
+                    type: mediaType,
+                    filename: name,
+                });
+                await wsClient.replyMedia(message.frame, mediaType, uploaded.media_id);
+                sent += 1;
+            }
+            catch (error) {
+                this.logger.warn({ err: error, path: directive.path }, "Failed to send OpenClaw WeCom output media");
+                failures.push(`${name}（发送失败）`);
+            }
+        }
+        return { sent, failures };
+    }
+    // Return the symlink-resolved real path if it still lives inside an
+    // allowlisted root (also symlink-resolved), else null. Guards against a
+    // symlink inside an allowed dir escaping to an arbitrary host file.
+    async resolveAllowedRealPath(filePath, allowedRoots) {
+        let realFile;
+        try {
+            realFile = await realpath(filePath);
+        }
+        catch {
+            return null;
+        }
+        for (const root of allowedRoots) {
+            let realRoot;
+            try {
+                realRoot = await realpath(root);
+            }
+            catch {
+                continue;
+            }
+            if (isPathWithinRoots(realFile, [realRoot])) {
+                return realFile;
+            }
+        }
+        return null;
+    }
+    async sendMarkdown(chatId, content) {
+        const wsClient = this.wsClient;
+        if (!wsClient?.isConnected) {
+            throw new Error("OpenClaw WeCom WebSocket is not connected");
+        }
+        for (const chunk of splitByUtf8Bytes(content, MAX_MARKDOWN_BYTES)) {
+            await wsClient.sendMessage(chatId, {
+                msgtype: "markdown",
+                markdown: { content: chunk },
+            });
+        }
+    }
+    async replyStream(options) {
+        const wsClient = this.wsClient;
+        const content = truncateByUtf8Bytes(options.content, MAX_STREAM_BYTES, STREAM_TRUNCATION_SUFFIX);
+        if (!wsClient?.isConnected) {
+            const error = new Error("OpenClaw WeCom WebSocket is not connected");
+            this.logger.warn({
+                err: error,
+                agentId: options.agentId,
+                chatId: options.message.chatId,
+                streamId: options.streamId,
+                finish: options.finish,
+            }, "Failed to send OpenClaw WeCom stream reply");
+            if (options.finish && options.fallbackToMarkdown) {
+                await this.sendMarkdownFallback(options.message.chatId, content);
+            }
+            return false;
+        }
+        try {
+            this.logger.debug({
+                agentId: options.agentId,
+                chatId: options.message.chatId,
+                streamId: options.streamId,
+                finish: options.finish,
+                msgId: options.message.frame.body?.msgid,
+                elapsedSinceMessageMs: this.now() - options.message.receivedAt,
+                contentBytes: Buffer.byteLength(content, "utf8"),
+            }, "Sending OpenClaw WeCom stream reply");
+            await wsClient.replyStream(options.message.frame, options.streamId, content, options.finish);
+            return true;
+        }
+        catch (error) {
+            this.logger.warn({
+                err: error,
+                agentId: options.agentId,
+                chatId: options.message.chatId,
+                streamId: options.streamId,
+                finish: options.finish,
+            }, "Failed to send OpenClaw WeCom stream reply");
+            if (options.finish && options.fallbackToMarkdown) {
+                await this.sendMarkdownFallback(options.message.chatId, content);
+            }
+            return false;
+        }
+    }
+    async sendMarkdownFallback(chatId, content) {
+        try {
+            await this.sendMarkdown(chatId, content);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, chatId }, "Failed to send OpenClaw WeCom markdown fallback");
+        }
+    }
+    updateConversationAgent(key, agentId) {
+        const state = this.conversations.get(key);
+        if (!state) {
+            return;
+        }
+        state.agentId = agentId;
+        state.lastActivityAt = this.now();
+    }
+    markConversationIdle(key, pending) {
+        const state = this.conversations.get(key);
+        if (!state || state.pending !== pending) {
+            return;
+        }
+        if (this.config.agentMode === "existing") {
+            this.conversations.delete(key);
+            return;
+        }
+        state.active = false;
+        state.lastActivityAt = this.now();
+        this.pruneConversations(state.lastActivityAt);
+    }
+    pruneConversations(now = this.now()) {
+        for (const [key, state] of this.conversations) {
+            if (!state.active && now - state.lastActivityAt >= this.conversationIdleTtlMs) {
+                this.conversations.delete(key);
+            }
+        }
+        while (this.conversations.size > this.maxConversations) {
+            if (!this.evictOldestIdleConversation()) {
+                break;
+            }
+        }
+    }
+    evictOldestIdleConversation() {
+        let oldestKey = null;
+        let oldestActivity = Number.POSITIVE_INFINITY;
+        for (const [key, state] of this.conversations) {
+            if (state.active || state.lastActivityAt >= oldestActivity) {
+                continue;
+            }
+            oldestKey = key;
+            oldestActivity = state.lastActivityAt;
+        }
+        if (!oldestKey) {
+            return false;
+        }
+        this.conversations.delete(oldestKey);
+        return true;
+    }
+}
+const IMAGE_FAILURE_REASONS = {
+    oversize: "超过大小上限",
+    timeout: "下载超时",
+    error: "下载失败",
+};
+function extractText(body) {
+    const parts = [];
+    if (body.msgtype === MessageType.Text && body.text?.content) {
+        parts.push(body.text.content);
+    }
+    else if (body.msgtype === MessageType.Voice && body.voice?.content) {
+        parts.push(body.voice.content);
+    }
+    else if (body.msgtype === MessageType.Mixed) {
+        parts.push(body.mixed.msg_item
+            .flatMap((item) => item.msgtype === "text" && item.text?.content ? [item.text.content] : [])
+            .join("\n"));
+    }
+    const quoteText = extractQuoteText(body);
+    if (quoteText) {
+        parts.push(quoteText);
+    }
+    return parts.filter(Boolean).join("\n");
+}
+function extractQuoteText(body) {
+    const quote = body.quote;
+    if (!quote) {
+        return "";
+    }
+    if (quote.msgtype === "text" && quote.text?.content) {
+        return `引用：${quote.text.content}`;
+    }
+    if (quote.msgtype === "voice" && quote.voice?.content) {
+        return `引用：${quote.voice.content}`;
+    }
+    if (quote.msgtype === "mixed" && quote.mixed?.msg_item) {
+        const text = quote.mixed.msg_item
+            .flatMap((item) => (item.msgtype === "text" && item.text?.content ? [item.text.content] : []))
+            .join("\n");
+        return text ? `引用：${text}` : "";
+    }
+    return "";
+}
+function extractAttachments(body) {
+    const attachments = [];
+    const pushImage = (image) => {
+        if (image?.url) {
+            attachments.push({ kind: "image", url: image.url, aesKey: image.aeskey });
+        }
+    };
+    const pushFile = (file) => {
+        if (file?.url) {
+            attachments.push({ kind: "file", url: file.url, aesKey: file.aeskey });
+        }
+    };
+    // Mixed items are typed as text/image only, but the wire allows extra fields
+    // (BaseMessage is `[key: string]: any`), so read a `file` item defensively to
+    // avoid silently dropping file attachments embedded in mixed messages.
+    const collectMixedItems = (items) => {
+        for (const item of items) {
+            if (item.msgtype === "image") {
+                pushImage(item.image);
+            }
+            else if (item.msgtype === "file") {
+                pushFile(item.file);
+            }
+        }
+    };
+    if (body.msgtype === MessageType.Image) {
+        pushImage(body.image);
+    }
+    else if (body.msgtype === MessageType.File) {
+        pushFile(body.file);
+    }
+    else if (body.msgtype === MessageType.Mixed) {
+        collectMixedItems(body.mixed.msg_item);
+    }
+    const quote = body.quote;
+    if (quote?.msgtype === "image") {
+        pushImage(quote.image);
+    }
+    else if (quote?.msgtype === "file") {
+        pushFile(quote.file);
+    }
+    else if (quote?.msgtype === "mixed" && quote.mixed?.msg_item) {
+        collectMixedItems(quote.mixed.msg_item);
+    }
+    return attachments;
+}
+function guessImageMimeType(filename) {
+    const ext = filename ? path.extname(filename).toLowerCase() : "";
+    switch (ext) {
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".bmp":
+            return "image/bmp";
+        default:
+            return "image/jpeg";
+    }
+}
+function mimeExtension(mimeType) {
+    switch (mimeType) {
+        case "image/png":
+            return ".png";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        case "image/bmp":
+            return ".bmp";
+        default:
+            return ".jpg";
+    }
+}
+function isPathWithinRoots(filePath, roots) {
+    const resolved = path.resolve(filePath);
+    return roots.some((root) => {
+        const relative = path.relative(root, resolved);
+        return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    });
+}
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`download timed out after ${ms}ms`)), ms);
+        timer.unref?.();
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function formatFailureSummary(failures) {
+    return ["部分媒体未能发送：", ...failures.map((item) => `- ${item}`)].join("\n");
+}
+function normalizeAllowlist(values) {
+    return new Set((values ?? []).map((value) => value.trim()).filter(Boolean));
+}
+function mergeAllowlist(current, incoming) {
+    return [
+        ...new Set([...(current ?? []), ...(incoming ?? [])].map((value) => value.trim()).filter(Boolean)),
+    ];
+}
+function hasExplicitAllowlist(config) {
+    return (normalizeAllowlist(config.allowUsers).size > 0 || normalizeAllowlist(config.allowChats).size > 0);
+}
+function normalizeWeComAgentConfig(input) {
+    const provider = isValidAgentProvider(input.provider ?? "")
+        ? input.provider
+        : DEFAULT_AGENT_PROVIDER;
+    const definition = getAgentProviderDefinition(provider);
+    const validModeIds = new Set(definition.modes.map((mode) => mode.id));
+    const requestedModeId = input.modeId?.trim();
+    const modeId = requestedModeId && validModeIds.has(requestedModeId)
+        ? requestedModeId
+        : (definition.defaultModeId ?? undefined);
+    const model = input.model?.trim() || definition.defaultModel;
+    const thinkingOptionId = normalizeThinkingOptionIdForProvider(provider, input.thinkingOptionId);
+    return {
+        provider,
+        ...(modeId ? { modeId } : {}),
+        ...(model ? { model } : {}),
+        ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+}
+function normalizeThinkingOptionIdForProvider(provider, thinkingOptionId) {
+    const normalized = thinkingOptionId?.trim();
+    if (!normalized || normalized === "default") {
+        return undefined;
+    }
+    if (provider === "codex") {
+        return ["minimal", "low", "medium", "high", "xhigh"].includes(normalized)
+            ? normalized
+            : undefined;
+    }
+    if (provider === "claude") {
+        return ["low", "medium", "high", "max"].includes(normalized) ? normalized : undefined;
+    }
+    return undefined;
+}
+function buildConnectionKey(config) {
+    return JSON.stringify({
+        enabled: config.enabled,
+        botId: config.botId ?? null,
+        secret: config.secret ?? null,
+        websocketUrl: config.websocketUrl ?? null,
+        pluginVersion: config.pluginVersion ?? null,
+    });
+}
+function splitByUtf8Bytes(text, maxBytes) {
+    const chunks = [];
+    let current = "";
+    let currentBytes = 0;
+    for (const char of text) {
+        const charBytes = Buffer.byteLength(char, "utf8");
+        if (current && currentBytes + charBytes > maxBytes) {
+            chunks.push(current);
+            current = "";
+            currentBytes = 0;
+        }
+        current += char;
+        currentBytes += charBytes;
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+function truncateByUtf8Bytes(text, maxBytes, suffix) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
+        return text;
+    }
+    const suffixBytes = Buffer.byteLength(suffix, "utf8");
+    if (suffixBytes >= maxBytes) {
+        return splitByUtf8Bytes(suffix, maxBytes)[0] ?? "";
+    }
+    const targetBytes = maxBytes - suffixBytes;
+    let result = "";
+    let resultBytes = 0;
+    for (const char of text) {
+        const charBytes = Buffer.byteLength(char, "utf8");
+        if (resultBytes + charBytes > targetBytes) {
+            break;
+        }
+        result += char;
+        resultBytes += charBytes;
+    }
+    return `${result}${suffix}`;
+}
+function formatProcessingReply(agentId, loadingTick = 0) {
+    const loadingText = formatLoadingText("已收到，Seawork 正在处理", loadingTick);
+    return agentId ? `${loadingText}\n\nAgent: ${agentId}` : loadingText;
+}
+function formatStreamingReply(agentId, assistantText, statusText, loadingTick) {
+    const content = assistantText.trim();
+    const status = statusText?.trim();
+    if (!status) {
+        return content || formatProcessingReply(agentId, loadingTick);
+    }
+    const loadingStatus = formatLoadingText(status, loadingTick);
+    if (!content) {
+        return `${formatProcessingReply(agentId, loadingTick)}\n\n_${loadingStatus}_`;
+    }
+    return `${content}\n\n_${loadingStatus}_`;
+}
+function formatFinalReply(agentId, text) {
+    const content = text.trim();
+    return content || `Agent ${agentId} 已完成本轮处理，但没有返回文本。`;
+}
+function formatTimelineStatus(item) {
+    if (item.type === "reasoning") {
+        return "正在推理";
+    }
+    if (item.type === "tool_call") {
+        if (item.status === "running") {
+            return "正在执行工具";
+        }
+        if (item.status === "completed") {
+            return "工具执行完成，继续处理";
+        }
+        if (item.status === "failed") {
+            return "工具执行失败，继续处理";
+        }
+        return "工具执行已取消，继续处理";
+    }
+    if (item.type === "compaction") {
+        return item.status === "loading" ? "正在整理上下文" : "上下文整理完成，继续处理";
+    }
+    return null;
+}
+function formatLoadingText(text, loadingTick) {
+    const suffix = LOADING_ELLIPSIS_FRAMES[loadingTick % LOADING_ELLIPSIS_FRAMES.length];
+    return `${text}${suffix}`;
+}
+function formatTurnFailedEvent(event) {
+    const base = event.error.trim();
+    const parts = [base.length > 0 ? base : "Provider run failed"];
+    const code = event.code?.trim();
+    if (code) {
+        parts.push(`code: ${code}`);
+    }
+    const diagnostic = event.diagnostic?.trim();
+    if (diagnostic && diagnostic !== base) {
+        parts.push(diagnostic);
+    }
+    return parts.join("\n\n");
+}
+function formatTurnCanceledEvent(event) {
+    const reason = event.reason.trim();
+    return reason ? `Seawork 已取消本轮处理：${reason}` : "Seawork 已取消本轮处理。";
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=bridge.js.map