@yanhaidao/wecom 2.4.160 → 2.5.110

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

@@ -1,221 +0,0 @@
-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());
-  });
-});

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

@@ -1,176 +0,0 @@
-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 type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { resolveAgentConfig, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
-
-import { resolveWecomMediaMaxBytes } from "../../config/index.js";
-
-function expandHomeDir(input: string): string {
-  if (input === "~") return os.homedir();
-  if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
-  return input;
-}
-
-function resolveOpenClawStateDir(): string {
-  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: string): string {
-  return agentId.trim().toLowerCase() || "main";
-}
-
-function normalizeMainKey(mainKey: unknown): string {
-  return typeof mainKey === "string" && mainKey.trim() ? mainKey.trim().toLowerCase() : "main";
-}
-
-function buildAgentMainSessionKey(cfg: OpenClawConfig, agentId: string): string {
-  if (cfg.session?.scope === "global") {
-    return "global";
-  }
-  return `agent:${normalizeAgentId(agentId)}:${normalizeMainKey(cfg.session?.mainKey)}`;
-}
-
-function slugifySessionKey(value: string): string {
-  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: {
-  cfg: OpenClawConfig;
-  agentId: string;
-  sessionKey: string;
-}): boolean {
-  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: {
-  cfg: OpenClawConfig;
-  agentId: string;
-  sessionKey: string;
-}): { workspaceDir: string; sandboxed: boolean } {
-  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: path.ParsedPath, suffix: number): string {
-  if (suffix === 0) {
-    return parsed.base || "attachment";
-  }
-  return `${parsed.name || "attachment"}-${suffix}${parsed.ext}`;
-}
-
-async function copyIntoWorkspaceInbound(params: {
-  sourcePath: string;
-  workspaceDir: string;
-  filename: string;
-}): Promise<{ absolutePath: string; relativePath: string }> {
-  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 as NodeJS.ErrnoException)?.code === "EEXIST") {
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-
-export async function stageWecomInboundMediaForSession(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  agentId: string;
-  sessionKey: string;
-  mediaPath: string;
-  filename?: string;
-}): Promise<string> {
-  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/src/capability/bot/service.ts

@@ -1,56 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-
-import type { WecomRuntimeEnv } from "../../types/runtime-context.js";
-import type { WecomAccountRuntime } from "../../app/account-runtime.js";
-import { BotWsSdkAdapter } from "../../transport/bot-ws/sdk-adapter.js";
-import { startBotWebhookTransport } from "../../transport/bot-webhook/http-handler.js";
-
-export class WecomBotCapabilityService {
-  private wsAdapter?: BotWsSdkAdapter;
-  private stopTransport?: () => void;
-
-  constructor(
-    private readonly runtime: WecomAccountRuntime,
-    private readonly cfg: OpenClawConfig,
-    private readonly runtimeEnv: WecomRuntimeEnv,
-  ) {}
-
-  start(): { transport: "bot-ws" | "bot-webhook"; descriptors: string[] } | undefined {
-    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(): void {
-    this.stopTransport?.();
-    this.stopTransport = undefined;
-    this.wsAdapter = undefined;
-  }
-}