@yanhaidao/wecom 2.3.270 → 2.4.120

package/src/agent/script-runner.ts

@@ -0,0 +1,186 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+import type {
+  WecomAgentEventRouteHandlerConfig,
+  WecomAgentScriptRuntimeConfig,
+} from "../types/index.js";
+
+export type AgentEventScriptEnvelope = {
+  version: "1.0";
+  channel: "wecom";
+  accountId: string;
+  receivedAt: number;
+  message: {
+    msgType: string;
+    eventType: string;
+    eventKey: string | null;
+    changeType: string | null;
+    fromUser: string;
+    toUser: string | null;
+    chatId: string | null;
+    agentId: number | null;
+    createTime: number | null;
+    msgId: string | null;
+    raw: Record<string, unknown>;
+  };
+  route: {
+    matchedRuleId: string;
+    handlerType: "node_script" | "python_script";
+  };
+};
+
+export type AgentEventScriptResponse = {
+  ok?: boolean;
+  action?: "none" | "reply_text";
+  reply?: {
+    text?: string;
+  };
+  chainToAgent?: boolean;
+  audit?: {
+    tags?: string[];
+  };
+  error?: string;
+};
+
+export type AgentEventScriptExecutionMeta = {
+  command: string;
+  entryPath: string;
+  durationMs: number;
+  exitCode: number | null;
+};
+
+function resolveAllowedRoots(runtime: WecomAgentScriptRuntimeConfig): string[] {
+  return (runtime.allowPaths ?? []).map((entry) => path.resolve(entry));
+}
+
+function resolveScriptEntry(entry: string): string {
+  return path.resolve(entry);
+}
+
+function ensureScriptAllowed(entryPath: string, runtime: WecomAgentScriptRuntimeConfig): void {
+  // 安全兜底：脚本执行必须显式开启
+  if (runtime.enabled !== true) {
+    throw new Error("script runtime is disabled");
+  }
+  // 安全兜底：必须配置允许目录，拒绝任意路径执行
+  const roots = resolveAllowedRoots(runtime);
+  if (roots.length === 0) {
+    throw new Error("script runtime allowPaths is empty");
+  }
+  const allowed = roots.some((root) => entryPath === root || entryPath.startsWith(`${root}${path.sep}`));
+  if (!allowed) {
+    throw new Error(`script path is not allowed: ${entryPath}`);
+  }
+}
+
+export async function runAgentEventScript(params: {
+  runtime: WecomAgentScriptRuntimeConfig | undefined;
+  handler: Extract<WecomAgentEventRouteHandlerConfig, { type: "node_script" | "python_script" }>;
+  envelope: AgentEventScriptEnvelope;
+}): Promise<{ response: AgentEventScriptResponse; meta: AgentEventScriptExecutionMeta }> {
+  const runtime = params.runtime ?? {};
+  const entryPath = resolveScriptEntry(params.handler.entry);
+  ensureScriptAllowed(entryPath, runtime);
+
+  // 优先使用 route 覆盖值，其次使用全局 runtime 默认值
+  const timeoutMs = params.handler.timeoutMs ?? runtime.defaultTimeoutMs ?? 5000;
+  const maxStdoutBytes = runtime.maxStdoutBytes ?? 262144;
+  const maxStderrBytes = runtime.maxStderrBytes ?? 131072;
+  const command = params.handler.type === "python_script"
+    ? runtime.pythonCommand ?? "python3"
+    : runtime.nodeCommand ?? "node";
+  const startedAt = Date.now();
+
+  return await new Promise<{ response: AgentEventScriptResponse; meta: AgentEventScriptExecutionMeta }>((resolve, reject) => {
+    const child = spawn(command, [entryPath], {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        PATH: process.env.PATH ?? "",
+      },
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let stdoutExceeded = false;
+    let stderrExceeded = false;
+    let settled = false;
+    let exitCode: number | null = null;
+
+    const finish = (fn: () => void): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+
+    const timer = setTimeout(() => {
+      // 超时强制终止，防止脚本阻塞事件处理链
+      child.kill("SIGKILL");
+      finish(() => reject(new Error(`script execution timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk: Buffer | string) => {
+      const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      // 限制输出体积，避免异常脚本刷爆内存/日志
+      if (Buffer.byteLength(stdout, "utf8") + Buffer.byteLength(value, "utf8") > maxStdoutBytes) {
+        stdoutExceeded = true;
+        return;
+      }
+      stdout += value;
+    });
+
+    child.stderr.on("data", (chunk: Buffer | string) => {
+      const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (Buffer.byteLength(stderr, "utf8") + Buffer.byteLength(value, "utf8") > maxStderrBytes) {
+        stderrExceeded = true;
+        return;
+      }
+      stderr += value;
+    });
+
+    child.on("error", (err) => {
+      finish(() => reject(err));
+    });
+
+    child.on("close", (code) => {
+      exitCode = code;
+      const meta: AgentEventScriptExecutionMeta = {
+        command,
+        entryPath,
+        durationMs: Date.now() - startedAt,
+        exitCode,
+      };
+      if (stdoutExceeded) {
+        finish(() => reject(new Error("script stdout exceeded limit")));
+        return;
+      }
+      if (stderrExceeded) {
+        finish(() => reject(new Error("script stderr exceeded limit")));
+        return;
+      }
+      if (code !== 0) {
+        finish(() => reject(new Error(`script exited with code ${code}: ${stderr.trim() || stdout.trim()}`)));
+        return;
+      }
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        // 空输出按无动作处理，减少脚本端样板代码
+        finish(() => resolve({ response: { ok: true, action: "none" }, meta }));
+        return;
+      }
+      try {
+        // 脚本协议要求 stdout 必须是 JSON
+        const parsed = JSON.parse(trimmed) as AgentEventScriptResponse;
+        finish(() => resolve({ response: parsed, meta }));
+      } catch (err) {
+        finish(() => reject(new Error(`script output is not valid JSON: ${String(err)}`)));
+      }
+    });
+
+    // 将完整 envelope 传给脚本，再关闭 stdin
+    child.stdin.write(JSON.stringify(params.envelope));
+    child.stdin.end();
+  });
+}

package/src/agent/test-fixtures/invalid-json-script.mjs

@@ -0,0 +1 @@
+process.stdout.write("this is not json");

package/src/agent/test-fixtures/reply-event-script.mjs

@@ -0,0 +1,29 @@
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  raw += chunk;
+});
+process.stdin.on("end", () => {
+  const payload = JSON.parse(raw || "{}");
+  const eventType = payload?.message?.eventType ?? "unknown";
+  const eventKey = payload?.message?.eventKey ?? "";
+  const changeType = payload?.message?.changeType ?? "";
+
+  if (eventKey === "PASS_TO_DEFAULT") {
+    process.stdout.write(JSON.stringify({
+      ok: true,
+      action: "none",
+      chainToAgent: true,
+    }));
+    return;
+  }
+
+  process.stdout.write(JSON.stringify({
+    ok: true,
+    action: "reply_text",
+    reply: {
+      text: `script:${eventType}:${eventKey}:${changeType}`,
+    },
+    chainToAgent: false,
+  }));
+});

package/src/agent/test-fixtures/reply-event-script.py

@@ -0,0 +1,17 @@
+import json
+import sys
+
+payload = json.load(sys.stdin)
+message = payload.get("message", {})
+event_type = message.get("eventType", "unknown")
+event_key = message.get("eventKey") or ""
+change_type = message.get("changeType") or ""
+
+json.dump({
+    "ok": True,
+    "action": "reply_text",
+    "reply": {
+        "text": f"python:{event_type}:{event_key}:{change_type}"
+    },
+    "chainToAgent": False
+}, sys.stdout)

package/src/app/account-runtime.ts

@@ -37,7 +37,7 @@ export class WecomAccountRuntime {
     } = {},
     private readonly statusSink?: (snapshot: Record<string, unknown>) => void,
   ) {
-    this.mediaService = new WecomMediaService(core);
+    this.mediaService = new WecomMediaService(core, cfg);
     this.runtimeStatus = {
       accountId: resolved.account.accountId,
       health: "idle",

package/src/capability/agent/upstream-delivery-service.ts

@@ -0,0 +1,96 @@
+import type { ResolvedAgentAccount } from "../../types/index.js";
+import { resolveScopedWecomTarget } from "../../target.js";
+import { deliverUpstreamAgentApiMedia, deliverUpstreamAgentApiText } from "../../transport/agent-api/upstream-delivery.js";
+import { canUseAgentApiDelivery } from "./fallback-policy.js";
+import { getWecomRuntime } from "../../runtime.js";
+
+/**
+ * 上下游企业消息发送服务
+ * 
+ * 使用下游企业的 access_token 和 agentId 发送消息
+ */
+export class WecomUpstreamAgentDeliveryService {
+  constructor(
+    private readonly upstreamAgent: ResolvedAgentAccount,
+    private readonly primaryAgent: ResolvedAgentAccount,
+  ) { }
+
+  assertAvailable(): void {
+    if (!canUseAgentApiDelivery(this.upstreamAgent)) {
+      throw new Error(
+        `WeCom upstream outbound requires channels.wecom.accounts.<accountId>.agent.agentId for upstream corp=${this.upstreamAgent.corpId}.`,
+      );
+    }
+  }
+
+  resolveTargetOrThrow(to: string | undefined) {
+    const scoped = resolveScopedWecomTarget(to, this.upstreamAgent.accountId);
+    if (!scoped) {
+      console.error(`[wecom-upstream-delivery] missing target account=${this.upstreamAgent.accountId}`);
+      throw new Error("WeCom upstream outbound requires a target (userid, partyid, tagid or chatid).");
+    }
+    if (scoped.accountId && scoped.accountId !== this.upstreamAgent.accountId) {
+      console.error(
+        `[wecom-upstream-delivery] account mismatch current=${this.upstreamAgent.accountId} targetAccount=${scoped.accountId} raw=${String(to ?? "")}`,
+      );
+      throw new Error(
+        `WeCom upstream outbound account mismatch: target belongs to account=${scoped.accountId}, current account=${this.upstreamAgent.accountId}.`,
+      );
+    }
+    const target = scoped.target;
+    if (target.chatid) {
+      console.warn(
+        `[wecom-upstream-delivery] blocked chat target account=${this.upstreamAgent.accountId} chatId=${target.chatid}`,
+      );
+      throw new Error(
+        `企业微信（WeCom）上下游 Agent 主动发送不支持向群 chatId 发送（chatId=${target.chatid}）。` +
+        `请改为发送给用户（userid / user:xxx）。`,
+      );
+    }
+    return target;
+  }
+
+  async sendText(params: { to: string | undefined; text: string }): Promise<void> {
+    this.assertAvailable();
+    const target = this.resolveTargetOrThrow(params.to);
+    console.log(
+      `[wecom-upstream-delivery] sendText account=${this.upstreamAgent.accountId} corpId=${this.upstreamAgent.corpId} to=${String(params.to ?? "")} len=${params.text.length}`,
+    );
+
+    const runtime = getWecomRuntime();
+    const chunks = runtime.channel.text.chunkText(params.text, 2048);
+
+    for (const chunk of chunks) {
+      if (!chunk.trim()) continue;
+      await deliverUpstreamAgentApiText({
+        upstreamAgent: this.upstreamAgent,
+        primaryAgent: this.primaryAgent,
+        target,
+        text: chunk,
+      });
+    }
+  }
+
+  async sendMedia(params: {
+    to: string | undefined;
+    text?: string;
+    buffer: Buffer;
+    filename: string;
+    contentType: string;
+  }): Promise<void> {
+    this.assertAvailable();
+    const target = this.resolveTargetOrThrow(params.to);
+    console.log(
+      `[wecom-upstream-delivery] sendMedia account=${this.upstreamAgent.accountId} corpId=${this.upstreamAgent.corpId} to=${String(params.to ?? "")} filename=${params.filename} contentType=${params.contentType}`,
+    );
+    await deliverUpstreamAgentApiMedia({
+      upstreamAgent: this.upstreamAgent,
+      primaryAgent: this.primaryAgent,
+      target,
+      buffer: params.buffer,
+      filename: params.filename,
+      contentType: params.contentType,
+      text: params.text,
+    });
+  }
+}

package/src/capability/bot/sandbox-media.test.ts

@@ -0,0 +1,221 @@
+import path from "node:path";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { stageWecomInboundMediaForSession } from "./sandbox-media.js";
+
+describe("stageWecomInboundMediaForSession", () => {
+  const root = path.join("/tmp", `wecom-sandbox-stage-${process.pid}`);
+
+  beforeEach(async () => {
+    await mkdir(root, { recursive: true });
+  });
+
+  afterEach(async () => {
+    vi.unstubAllEnvs();
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("stages inbound media into the session sandbox workspace using channels.wecom.mediaMaxMb", async () => {
+    const mediaPath = path.join(root, "openclaw-media", "inbound", "big.bin");
+    const agentWorkspace = path.join(root, "agent-workspace");
+    const sandboxRoot = path.join(root, "sandboxes");
+
+    await mkdir(path.dirname(mediaPath), { recursive: true });
+    await mkdir(agentWorkspace, { recursive: true });
+    await writeFile(mediaPath, Buffer.alloc(6 * 1024 * 1024, 7));
+
+    const staged = await stageWecomInboundMediaForSession({
+      cfg: {
+        channels: {
+          wecom: {
+            mediaMaxMb: 8,
+          },
+        },
+        agents: {
+          list: [
+            {
+              id: "ops",
+              workspace: agentWorkspace,
+              sandbox: {
+                mode: "non-main",
+                scope: "session",
+                workspaceRoot: sandboxRoot,
+                workspaceAccess: "ro",
+                docker: {
+                  workdir: "/workspace",
+                },
+              },
+            },
+          ],
+        },
+      } as any,
+      accountId: "default",
+      agentId: "ops",
+      sessionKey: "agent:ops:wecom:default:dm:zhangsan",
+      mediaPath,
+      filename: "big.bin",
+    });
+
+    expect(staged).toMatch(/^media\/inbound\/big\.bin$/);
+    const sandboxEntries = await readdir(sandboxRoot);
+    const stagedBuffer = await readFile(
+      path.join(sandboxRoot, sandboxEntries[0]!, "media", "inbound", "big.bin"),
+    );
+    expect(stagedBuffer.byteLength).toBe(6 * 1024 * 1024);
+  });
+
+  it("uses the default sandbox workspace root when workspaceRoot is omitted", async () => {
+    vi.stubEnv("OPENCLAW_STATE_DIR", root);
+    const mediaPath = path.join(root, "openclaw-media", "inbound", "default-root.bin");
+    const agentWorkspace = path.join(root, "agent-workspace");
+
+    await mkdir(path.dirname(mediaPath), { recursive: true });
+    await mkdir(agentWorkspace, { recursive: true });
+    await writeFile(mediaPath, Buffer.alloc(2 * 1024 * 1024, 5));
+
+    const staged = await stageWecomInboundMediaForSession({
+      cfg: {
+        channels: {
+          wecom: {
+            mediaMaxMb: 8,
+          },
+        },
+        agents: {
+          list: [
+            {
+              id: "ops",
+              workspace: agentWorkspace,
+              sandbox: {
+                mode: "non-main",
+                scope: "session",
+                workspaceAccess: "ro",
+                docker: {
+                  workdir: "/workspace",
+                },
+              },
+            },
+          ],
+        },
+      } as any,
+      accountId: "default",
+      agentId: "ops",
+      sessionKey: "agent:ops:wecom:default:dm:lisi",
+      mediaPath,
+      filename: "default-root.bin",
+    });
+
+    expect(staged).toMatch(/^media\/inbound\/default-root\.bin$/);
+    const sandboxEntries = await readdir(path.join(root, "sandboxes"));
+    const stagedBuffer = await readFile(
+      path.join(root, "sandboxes", sandboxEntries[0]!, "media", "inbound", "default-root.bin"),
+    );
+    expect(stagedBuffer.byteLength).toBe(2 * 1024 * 1024);
+  });
+
+  it("stages inbound media into the agent workspace for non-sandbox sessions", async () => {
+    const mediaPath = path.join(root, "openclaw-media", "inbound", "small.bin");
+    const agentWorkspace = path.join(root, "agent-workspace");
+
+    await mkdir(path.dirname(mediaPath), { recursive: true });
+    await mkdir(agentWorkspace, { recursive: true });
+    await writeFile(mediaPath, Buffer.alloc(1024, 1));
+
+    const staged = await stageWecomInboundMediaForSession({
+      cfg: {
+        channels: {
+          wecom: {
+            mediaMaxMb: 8,
+          },
+        },
+        agents: {
+          list: [
+            {
+              id: "ops",
+              workspace: agentWorkspace,
+              sandbox: {
+                mode: "off",
+                scope: "session",
+                workspaceRoot: path.join(root, "sandboxes"),
+                workspaceAccess: "ro",
+                docker: {
+                  workdir: "/workspace",
+                },
+              },
+            },
+          ],
+        },
+      } as any,
+      accountId: "default",
+      agentId: "ops",
+      sessionKey: "agent:ops:wecom:default:dm:zhangsan",
+      mediaPath,
+      filename: "small.bin",
+    });
+
+    expect(staged).toBe(path.join(agentWorkspace, "media", "inbound", "small.bin"));
+    const stagedBuffer = await readFile(staged);
+    expect(stagedBuffer.byteLength).toBe(1024);
+  });
+
+  it("allocates distinct staged filenames for concurrent same-name uploads", async () => {
+    const mediaPathA = path.join(root, "openclaw-media", "inbound", "dup-a.bin");
+    const mediaPathB = path.join(root, "openclaw-media", "inbound", "dup-b.bin");
+    const agentWorkspace = path.join(root, "agent-workspace");
+
+    await mkdir(path.dirname(mediaPathA), { recursive: true });
+    await mkdir(agentWorkspace, { recursive: true });
+    await writeFile(mediaPathA, Buffer.from("first"));
+    await writeFile(mediaPathB, Buffer.from("second"));
+
+    const cfg = {
+      channels: {
+        wecom: {
+          mediaMaxMb: 8,
+        },
+      },
+      agents: {
+        list: [
+          {
+            id: "ops",
+            workspace: agentWorkspace,
+            sandbox: {
+              mode: "off",
+              scope: "session",
+              workspaceAccess: "ro",
+              docker: {
+                workdir: "/workspace",
+              },
+            },
+          },
+        ],
+      },
+    } as any;
+
+    const [stagedA, stagedB] = await Promise.all([
+      stageWecomInboundMediaForSession({
+        cfg,
+        accountId: "default",
+        agentId: "ops",
+        sessionKey: "agent:ops:wecom:default:dm:zhangsan",
+        mediaPath: mediaPathA,
+        filename: "dup.bin",
+      }),
+      stageWecomInboundMediaForSession({
+        cfg,
+        accountId: "default",
+        agentId: "ops",
+        sessionKey: "agent:ops:wecom:default:dm:lisi",
+        mediaPath: mediaPathB,
+        filename: "dup.bin",
+      }),
+    ]);
+
+    expect(stagedA).not.toBe(stagedB);
+    expect([path.basename(stagedA), path.basename(stagedB)].sort()).toEqual(["dup-1.bin", "dup.bin"]);
+    expect((await readFile(stagedA)).toString()).toMatch(/first|second/);
+    expect((await readFile(stagedB)).toString()).toMatch(/first|second/);
+    expect((await readFile(stagedA)).toString()).not.toBe((await readFile(stagedB)).toString());
+  });
+});