@yanhaidao/wecom 2.4.120 → 2.5.110

package/dist/src/capability/bot/fallback-delivery.js

@@ -0,0 +1,147 @@
+import { resolveWecomAccount } from "../../config/index.js";
+import { wecomFetch } from "../../http.js";
+import { LIMITS } from "../../monitor/state.js";
+import { sendMedia as sendAgentMedia, sendText as sendAgentText, uploadMedia } from "../../transport/agent-api/core.js";
+import { buildStreamReplyFromState } from "../../transport/bot-webhook/protocol.js";
+import { useActiveReplyOnce } from "../../transport/bot-webhook/active-reply.js";
+import { guessContentTypeFromPath } from "../../transport/bot-webhook/inbound-normalizer.js";
+const STREAM_MAX_DM_BYTES = 200_000;
+export function appendDmContent(state, text) {
+    const next = state.dmContent ? `${state.dmContent}\n\n${text}`.trim() : text.trim();
+    const buf = Buffer.from(next, "utf8");
+    state.dmContent = buf.length <= STREAM_MAX_DM_BYTES ? next : buf.subarray(buf.length - STREAM_MAX_DM_BYTES).toString("utf8");
+}
+export function resolveAgentAccountOrUndefined(cfg, accountId) {
+    const agent = resolveWecomAccount({ cfg, accountId }).agent;
+    return agent?.configured ? agent : undefined;
+}
+export function buildFallbackPrompt(params) {
+    const who = params.userId ? `（${params.userId}）` : "";
+    const scope = params.chatType === "group" ? "群聊" : params.chatType === "direct" ? "私聊" : "会话";
+    if (!params.agentConfigured) {
+        return `${scope}中需要通过应用私信发送${params.filename ? `（${params.filename}）` : ""}，但管理员尚未配置企业微信自建应用（Agent）通道。请联系管理员配置后再试。${who}`.trim();
+    }
+    if (!params.userId) {
+        return `${scope}中需要通过应用私信兜底发送${params.filename ? `（${params.filename}）` : ""}，但本次回调未能识别触发者 userid（请检查企微回调字段 from.userid / fromuserid）。请联系管理员排查配置。`.trim();
+    }
+    if (params.kind === "media") {
+        return `已生成文件${params.filename ? `（${params.filename}）` : ""}，将通过应用私信发送给你。${who}`.trim();
+    }
+    if (params.kind === "timeout") {
+        return `内容较长，为避免超时，后续内容将通过应用私信发送给你。${who}`.trim();
+    }
+    return `交付出现异常，已尝试通过应用私信发送给你。${who}`.trim();
+}
+export async function sendBotFallbackPromptNow(params) {
+    await useActiveReplyOnce(params.streamId, async ({ responseUrl, proxyUrl }) => {
+        const payload = {
+            msgtype: "stream",
+            stream: {
+                id: params.streamId,
+                finish: true,
+                content: params.text.trim() || "1",
+            },
+        };
+        const res = await wecomFetch(responseUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        }, { proxyUrl, timeoutMs: LIMITS.REQUEST_TIMEOUT_MS });
+        if (!res.ok) {
+            throw new Error(`fallback prompt push failed: ${res.status}`);
+        }
+    });
+}
+export async function pushFinalStreamReplyNow(params) {
+    const finalReply = buildStreamReplyFromState(params.state);
+    await useActiveReplyOnce(params.streamId, async ({ responseUrl, proxyUrl }) => {
+        const res = await wecomFetch(responseUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(finalReply),
+        }, { proxyUrl, timeoutMs: LIMITS.REQUEST_TIMEOUT_MS });
+        if (!res.ok) {
+            throw new Error(`final stream push failed: ${res.status}`);
+        }
+    });
+}
+export async function sendAgentDmText(params) {
+    const chunks = params.core.channel.text.chunkText(params.text, 2048);
+    for (const chunk of chunks) {
+        const trimmed = chunk.trim();
+        if (!trimmed)
+            continue;
+        await sendAgentText({ agent: params.agent, toUser: params.userId, text: trimmed });
+    }
+}
+export async function sendAgentDmMedia(params) {
+    let buffer;
+    let inferredContentType = params.contentType;
+    const looksLikeUrl = /^https?:\/\//i.test(params.mediaUrlOrPath);
+    if (looksLikeUrl) {
+        const res = await fetch(params.mediaUrlOrPath, { signal: AbortSignal.timeout(30_000) });
+        if (!res.ok)
+            throw new Error(`media download failed: ${res.status}`);
+        buffer = Buffer.from(await res.arrayBuffer());
+        inferredContentType = inferredContentType || res.headers.get("content-type") || "application/octet-stream";
+    }
+    else {
+        const fs = await import("node:fs/promises");
+        buffer = await fs.readFile(params.mediaUrlOrPath);
+    }
+    let mediaType = "file";
+    const ct = (inferredContentType || "").toLowerCase();
+    if (ct.startsWith("image/"))
+        mediaType = "image";
+    else if (ct.startsWith("audio/"))
+        mediaType = "voice";
+    else if (ct.startsWith("video/"))
+        mediaType = "video";
+    const mediaId = await uploadMedia({
+        agent: params.agent,
+        type: mediaType,
+        buffer,
+        filename: params.filename,
+    });
+    await sendAgentMedia({
+        agent: params.agent,
+        toUser: params.userId,
+        mediaId,
+        mediaType,
+    });
+}
+export function extractLocalImagePathsFromText(params) {
+    const text = params.text;
+    const mustAlsoAppearIn = params.mustAlsoAppearIn;
+    if (!text.trim())
+        return [];
+    const exts = "(png|jpg|jpeg|gif|webp|bmp)";
+    const re = new RegExp(String.raw `(\/(?:Users|tmp|root|home)\/[^\s"'<>]+?\.${exts})`, "gi");
+    const found = new Set();
+    let m;
+    while ((m = re.exec(text))) {
+        const p = m[1];
+        if (!p)
+            continue;
+        if (!mustAlsoAppearIn.includes(p))
+            continue;
+        found.add(p);
+    }
+    return Array.from(found);
+}
+export function extractLocalFilePathsFromText(text) {
+    if (!text.trim())
+        return [];
+    const re = /\/(?:Users|tmp|root|home)\/[^\s"'<>]+/g;
+    const found = new Set();
+    let m;
+    while ((m = re.exec(text))) {
+        const p = m[0]?.trim();
+        if (p)
+            found.add(p);
+    }
+    return Array.from(found);
+}
+export function guessLocalPathContentType(filePath) {
+    return guessContentTypeFromPath(filePath);
+}

package/dist/src/capability/bot/local-path-delivery.js

@@ -0,0 +1,178 @@
+import crypto from "node:crypto";
+import { wecomFetch } from "../../http.js";
+import { LIMITS } from "../../monitor/state.js";
+import { getActiveReplyUrl, useActiveReplyOnce } from "../../transport/bot-webhook/active-reply.js";
+import { buildStreamReplyFromState } from "../../transport/bot-webhook/protocol.js";
+import { buildFallbackPrompt, extractLocalFilePathsFromText, guessLocalPathContentType, resolveAgentAccountOrUndefined, sendAgentDmMedia, sendBotFallbackPromptNow, } from "./fallback-delivery.js";
+export async function handleDirectLocalPathIntent(params) {
+    const { streamStore, target, streamId, rawBody, userId, chatType, logVerbose, looksLikeSendLocalFileIntent } = params;
+    const directLocalPaths = extractLocalFilePathsFromText(rawBody);
+    if (directLocalPaths.length) {
+        logVerbose(target, `local-path: 检测到用户消息包含本机路径 count=${directLocalPaths.length} intent=${looksLikeSendLocalFileIntent(rawBody)}`);
+    }
+    if (!directLocalPaths.length || !looksLikeSendLocalFileIntent(rawBody)) {
+        return false;
+    }
+    const fs = await import("node:fs/promises");
+    const pathModule = await import("node:path");
+    const imageExts = new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
+    const imagePaths = [];
+    const otherPaths = [];
+    for (const p of directLocalPaths) {
+        const ext = pathModule.extname(p).slice(1).toLowerCase();
+        if (imageExts.has(ext))
+            imagePaths.push(p);
+        else
+            otherPaths.push(p);
+    }
+    if (imagePaths.length > 0 && otherPaths.length === 0) {
+        const loaded = [];
+        for (const p of imagePaths) {
+            try {
+                const buf = await fs.readFile(p);
+                const base64 = buf.toString("base64");
+                const md5 = crypto.createHash("md5").update(buf).digest("hex");
+                loaded.push({ base64, md5, path: p });
+            }
+            catch (err) {
+                target.runtime.error?.(`local-path: 读取图片失败 path=${p}: ${String(err)}`);
+            }
+        }
+        if (loaded.length > 0) {
+            streamStore.updateStream(streamId, (s) => {
+                s.images = loaded.map(({ base64, md5 }) => ({ base64, md5 }));
+                s.content = loaded.length === 1 ? `已发送图片（${pathModule.basename(loaded[0].path)}）` : `已发送 ${loaded.length} 张图片`;
+                s.finished = true;
+            });
+            const responseUrl = getActiveReplyUrl(streamId);
+            if (responseUrl) {
+                try {
+                    const finalReply = buildStreamReplyFromState(streamStore.getStream(streamId));
+                    await useActiveReplyOnce(streamId, async ({ responseUrl, proxyUrl }) => {
+                        const res = await wecomFetch(responseUrl, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify(finalReply),
+                        }, { proxyUrl, timeoutMs: LIMITS.REQUEST_TIMEOUT_MS });
+                        if (!res.ok)
+                            throw new Error(`local-path image push failed: ${res.status}`);
+                    });
+                    logVerbose(target, `local-path: 已通过 Bot response_url 推送图片 frames=final images=${loaded.length}`);
+                }
+                catch (err) {
+                    target.runtime.error?.(`local-path: Bot 主动推送图片失败（将依赖 stream_refresh 拉取）: ${String(err)}`);
+                }
+            }
+            else {
+                logVerbose(target, "local-path: 无 response_url，等待 stream_refresh 拉取最终图片");
+            }
+            streamStore.onStreamFinished(streamId);
+            return true;
+        }
+        const agentCfg = resolveAgentAccountOrUndefined(target.config, target.account.accountId);
+        const agentOk = Boolean(agentCfg);
+        const fallbackName = imagePaths.length === 1 ? (imagePaths[0].split("/").pop() || "image") : `${imagePaths.length} 张图片`;
+        const prompt = buildFallbackPrompt({
+            kind: "media",
+            agentConfigured: agentOk,
+            userId,
+            filename: fallbackName,
+            chatType,
+        });
+        streamStore.updateStream(streamId, (s) => {
+            s.fallbackMode = "error";
+            s.finished = true;
+            s.content = prompt;
+            s.fallbackPromptSentAt = s.fallbackPromptSentAt ?? Date.now();
+        });
+        try {
+            await sendBotFallbackPromptNow({ streamId, text: prompt });
+            logVerbose(target, "local-path: 图片读取失败后已推送兜底提示");
+        }
+        catch (err) {
+            target.runtime.error?.(`local-path: 图片读取失败后的兜底提示推送失败: ${String(err)}`);
+        }
+        if (agentCfg && userId && userId !== "unknown") {
+            for (const p of imagePaths) {
+                const guessedType = guessLocalPathContentType(p);
+                try {
+                    await sendAgentDmMedia({
+                        agent: agentCfg,
+                        userId,
+                        mediaUrlOrPath: p,
+                        contentType: guessedType,
+                        filename: p.split("/").pop() || "image",
+                    });
+                    streamStore.updateStream(streamId, (s) => {
+                        s.agentMediaKeys = Array.from(new Set([...(s.agentMediaKeys ?? []), p]));
+                    });
+                    logVerbose(target, `local-path: 图片已通过 Agent 私信发送 user=${userId} path=${p} contentType=${guessedType ?? "unknown"}`);
+                }
+                catch (err) {
+                    target.runtime.error?.(`local-path: 图片 Agent 私信兜底失败 path=${p}: ${String(err)}`);
+                }
+            }
+        }
+        streamStore.onStreamFinished(streamId);
+        return true;
+    }
+    if (otherPaths.length > 0) {
+        const agentCfg = resolveAgentAccountOrUndefined(target.config, target.account.accountId);
+        const agentOk = Boolean(agentCfg);
+        const filename = otherPaths.length === 1 ? otherPaths[0].split("/").pop() : `${otherPaths.length} 个文件`;
+        const prompt = buildFallbackPrompt({
+            kind: "media",
+            agentConfigured: agentOk,
+            userId,
+            filename,
+            chatType,
+        });
+        streamStore.updateStream(streamId, (s) => {
+            s.fallbackMode = "media";
+            s.finished = true;
+            s.content = prompt;
+            s.fallbackPromptSentAt = s.fallbackPromptSentAt ?? Date.now();
+        });
+        try {
+            await sendBotFallbackPromptNow({ streamId, text: prompt });
+            logVerbose(target, "local-path: 文件兜底提示已推送");
+        }
+        catch (err) {
+            target.runtime.error?.(`local-path: 文件兜底提示推送失败: ${String(err)}`);
+        }
+        if (!agentCfg) {
+            streamStore.onStreamFinished(streamId);
+            return true;
+        }
+        if (!userId || userId === "unknown") {
+            target.runtime.error?.("local-path: 无法识别触发者 userId，无法 Agent 私信发送文件");
+            streamStore.onStreamFinished(streamId);
+            return true;
+        }
+        for (const p of otherPaths) {
+            const alreadySent = streamStore.getStream(streamId)?.agentMediaKeys?.includes(p);
+            if (alreadySent)
+                continue;
+            const guessedType = guessLocalPathContentType(p);
+            try {
+                await sendAgentDmMedia({
+                    agent: agentCfg,
+                    userId,
+                    mediaUrlOrPath: p,
+                    contentType: guessedType,
+                    filename: p.split("/").pop() || "file",
+                });
+                streamStore.updateStream(streamId, (s) => {
+                    s.agentMediaKeys = Array.from(new Set([...(s.agentMediaKeys ?? []), p]));
+                });
+                logVerbose(target, `local-path: 文件已通过 Agent 私信发送 user=${userId} path=${p} contentType=${guessedType ?? "unknown"}`);
+            }
+            catch (err) {
+                target.runtime.error?.(`local-path: Agent 私信发送文件失败 path=${p}: ${String(err)}`);
+            }
+        }
+        streamStore.onStreamFinished(streamId);
+        return true;
+    }
+    return false;
+}

package/dist/src/capability/bot/sandbox-media.js

@@ -0,0 +1,138 @@
+import crypto from "node:crypto";
+import { constants } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { copyFile, mkdir, stat } from "node:fs/promises";
+import { resolveAgentConfig, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveWecomMediaMaxBytes } from "../../config/index.js";
+function expandHomeDir(input) {
+    if (input === "~")
+        return os.homedir();
+    if (input.startsWith("~/"))
+        return path.join(os.homedir(), input.slice(2));
+    return input;
+}
+function resolveOpenClawStateDir() {
+    const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+    if (override) {
+        return path.resolve(expandHomeDir(override));
+    }
+    return path.join(os.homedir(), ".openclaw");
+}
+function normalizeAgentId(agentId) {
+    return agentId.trim().toLowerCase() || "main";
+}
+function normalizeMainKey(mainKey) {
+    return typeof mainKey === "string" && mainKey.trim() ? mainKey.trim().toLowerCase() : "main";
+}
+function buildAgentMainSessionKey(cfg, agentId) {
+    if (cfg.session?.scope === "global") {
+        return "global";
+    }
+    return `agent:${normalizeAgentId(agentId)}:${normalizeMainKey(cfg.session?.mainKey)}`;
+}
+function slugifySessionKey(value) {
+    const trimmed = value.trim() || "session";
+    const hash = crypto.createHash("sha256").update(trimmed).digest("hex").slice(0, 8);
+    const prefix = trimmed
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32) || "session";
+    return `${prefix}-${hash}`;
+}
+function isSandboxedSession(params) {
+    const sandbox = resolveAgentConfig(params.cfg, params.agentId)?.sandbox;
+    if (!sandbox || sandbox.mode === "off") {
+        return false;
+    }
+    if (sandbox.mode === "all") {
+        return true;
+    }
+    return params.sessionKey.trim().toLowerCase() !== buildAgentMainSessionKey(params.cfg, params.agentId);
+}
+function resolveSessionWorkspaceTarget(params) {
+    const sandbox = resolveAgentConfig(params.cfg, params.agentId)?.sandbox;
+    const agentWorkspaceDirRaw = resolveAgentWorkspaceDir(params.cfg, params.agentId);
+    const agentWorkspaceDir = path.resolve(expandHomeDir(agentWorkspaceDirRaw || process.cwd()));
+    if (!sandbox || !isSandboxedSession(params)) {
+        return {
+            workspaceDir: agentWorkspaceDir,
+            sandboxed: false,
+        };
+    }
+    if (sandbox.workspaceAccess === "rw" || !sandbox.workspaceRoot) {
+        if (sandbox.workspaceAccess === "rw") {
+            return {
+                workspaceDir: agentWorkspaceDir,
+                sandboxed: true,
+            };
+        }
+        return {
+            workspaceDir: path.join(resolveOpenClawStateDir(), "sandboxes", slugifySessionKey(params.sessionKey.trim() || "main")),
+            sandboxed: true,
+        };
+    }
+    const workspaceRoot = path.resolve(expandHomeDir(sandbox.workspaceRoot));
+    const scopeKey = sandbox.scope === "shared"
+        ? "shared"
+        : sandbox.scope === "session"
+            ? params.sessionKey.trim() || "main"
+            : `agent:${normalizeAgentId(params.agentId)}`;
+    if (sandbox.scope === "shared") {
+        return {
+            workspaceDir: workspaceRoot,
+            sandboxed: true,
+        };
+    }
+    return {
+        workspaceDir: path.join(workspaceRoot, slugifySessionKey(scopeKey)),
+        sandboxed: true,
+    };
+}
+function buildStagedFilenameCandidate(parsed, suffix) {
+    if (suffix === 0) {
+        return parsed.base || "attachment";
+    }
+    return `${parsed.name || "attachment"}-${suffix}${parsed.ext}`;
+}
+async function copyIntoWorkspaceInbound(params) {
+    const inboundDir = path.join(params.workspaceDir, "media", "inbound");
+    await mkdir(inboundDir, { recursive: true });
+    const parsed = path.parse(params.filename);
+    for (let suffix = 0;; suffix += 1) {
+        const candidate = buildStagedFilenameCandidate(parsed, suffix);
+        const absolutePath = path.join(inboundDir, candidate);
+        try {
+            await copyFile(params.sourcePath, absolutePath, constants.COPYFILE_EXCL);
+            return {
+                absolutePath,
+                relativePath: path.posix.join("media", "inbound", candidate),
+            };
+        }
+        catch (error) {
+            if (error?.code === "EEXIST") {
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+export async function stageWecomInboundMediaForSession(params) {
+    const target = resolveSessionWorkspaceTarget({
+        cfg: params.cfg,
+        agentId: params.agentId,
+        sessionKey: params.sessionKey,
+    });
+    const maxBytes = resolveWecomMediaMaxBytes(params.cfg, params.accountId);
+    const sourceStat = await stat(params.mediaPath);
+    if (sourceStat.size > maxBytes) {
+        throw new Error(`Inbound media size ${(sourceStat.size / (1024 * 1024)).toFixed(2)}MB exceeds channels.wecom.mediaMaxMb ${(maxBytes / (1024 * 1024)).toFixed(2)}MB before workspace staging`);
+    }
+    const staged = await copyIntoWorkspaceInbound({
+        sourcePath: params.mediaPath,
+        workspaceDir: target.workspaceDir,
+        filename: params.filename || path.basename(params.mediaPath),
+    });
+    return target.sandboxed ? staged.relativePath : staged.absolutePath;
+}

package/dist/src/capability/bot/service.js

@@ -0,0 +1,49 @@
+import { BotWsSdkAdapter } from "../../transport/bot-ws/sdk-adapter.js";
+import { startBotWebhookTransport } from "../../transport/bot-webhook/http-handler.js";
+export class WecomBotCapabilityService {
+    runtime;
+    cfg;
+    runtimeEnv;
+    wsAdapter;
+    stopTransport;
+    constructor(runtime, cfg, runtimeEnv) {
+        this.runtime = runtime;
+        this.cfg = cfg;
+        this.runtimeEnv = runtimeEnv;
+    }
+    start() {
+        const bot = this.runtime.account.bot;
+        if (!bot?.configured) {
+            return undefined;
+        }
+        if (bot.primaryTransport === "ws") {
+            this.wsAdapter = new BotWsSdkAdapter(this.runtime, {
+                info: this.runtimeEnv.log,
+                warn: this.runtimeEnv.log,
+                error: this.runtimeEnv.error,
+            });
+            this.wsAdapter.start();
+            this.stopTransport = () => this.wsAdapter?.stop();
+            return {
+                transport: "bot-ws",
+                descriptors: ["ws:primary"],
+            };
+        }
+        const webhook = startBotWebhookTransport({
+            account: bot,
+            cfg: this.cfg,
+            runtime: this.runtime,
+            runtimeEnv: this.runtimeEnv,
+        });
+        this.stopTransport = webhook.stop;
+        return {
+            transport: "bot-webhook",
+            descriptors: webhook.paths,
+        };
+    }
+    stop() {
+        this.stopTransport?.();
+        this.stopTransport = undefined;
+        this.wsAdapter = undefined;
+    }
+}