@yanhaidao/wecom 2.3.180 → 2.3.260

package/src/capability/doc/tool.ts

@@ -1189,11 +1189,12 @@ export function registerWecomDocTools(api: OpenClawPluginApi) {
               });
             }
             case "smartsheet_add_records": {
-              const result = await docClient.smartTableOperate({
+              const result = await docClient.smartTableAddRecords({
                 agent: account,
                 docId: params.docId,
-                operation: "add_records",
-                bodyData: params,
+                sheetId: params.sheetId,
+                records: params.records,
+                key_type: params.key_type,
               });
               return buildToolResult({
                 ok: true,
@@ -1205,11 +1206,11 @@ export function registerWecomDocTools(api: OpenClawPluginApi) {
               });
             }
             case "smartsheet_update_records": {
-              const result = await docClient.smartTableOperate({
+              const result = await docClient.smartTableUpdateRecords({
                 agent: account,
                 docId: params.docId,
-                operation: "update_records",
-                bodyData: params,
+                sheetId: params.sheetId,
+                records: params.records,
               });
               return buildToolResult({
                 ok: true,
@@ -1350,7 +1351,13 @@ export function registerWecomDocTools(api: OpenClawPluginApi) {
               });
             }
             case "smartsheet_add_fields": {
-              const result = await docClient.smartTableAddFields({ agent: account, ...params });
+              const result = await docClient.smartTableAddFields({ 
+                agent: account, 
+                docId: params.docId, 
+                sheetId: params.sheetId, 
+                fields: params.fields,
+                autoCleanupDefaultField: params.autoCleanupDefaultField !== false, // Default true
+              });
               return buildToolResult({
                 ok: true,
                 action,

package/src/channel.ts

@@ -6,7 +6,7 @@ import type {
 import {
   deleteAccountFromConfigSection,
   setAccountEnabledInConfigSection,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/core";
 
 import {
   DEFAULT_ACCOUNT_ID,

package/src/config/index.ts

@@ -12,5 +12,11 @@ export {
 export { resolveWecomRuntimeAccount, resolveWecomRuntimeConfig, type ResolvedRuntimeAccount, type ResolvedRuntimeConfig } from "./runtime-config.js";
 export { resolveDerivedPath, resolveDerivedPathSummary } from "./derived-paths.js";
 export { resolveWecomEgressProxyUrl, resolveWecomEgressProxyUrlFromNetwork } from "./network.js";
-export { DEFAULT_WECOM_MEDIA_MAX_BYTES, resolveWecomMediaMaxBytes } from "./media.js";
+export {
+  DEFAULT_WECOM_MEDIA_MAX_BYTES,
+  getWecomDefaultMediaLocalRoots,
+  resolveWecomConfiguredMediaLocalRoots,
+  resolveWecomMediaMaxBytes,
+  resolveWecomMergedMediaLocalRoots,
+} from "./media.js";
 export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/src/config/media.test.ts

@@ -0,0 +1,113 @@
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots } from "./media.js";
+
+describe("resolveWecomMergedMediaLocalRoots", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("merges defaults with configured local roots", () => {
+    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-state");
+
+    const roots = resolveWecomMergedMediaLocalRoots({
+      cfg: {
+        channels: {
+          wecom: {
+            media: {
+              localRoots: ["~/Downloads", "/tmp/custom-root"],
+            },
+          },
+        },
+      } as never,
+    });
+
+    expect(roots).toEqual(
+      expect.arrayContaining([
+        path.resolve(resolvePreferredOpenClawTmpDir()),
+        "/tmp/wecom-state",
+        "/tmp/wecom-state/media",
+        "/tmp/wecom-state/agents",
+        "/tmp/wecom-state/workspace",
+        "/tmp/wecom-state/sandboxes",
+        path.resolve(os.homedir(), "Desktop"),
+        path.resolve(os.homedir(), "Documents"),
+        path.resolve(os.homedir(), "Downloads"),
+        path.resolve(os.homedir(), "Movies"),
+        path.resolve(os.homedir(), "Pictures"),
+        "/tmp/custom-root",
+      ]),
+    );
+  });
+
+  it("keeps defaults, base roots, and configured roots without duplicates", () => {
+    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-state");
+
+    const roots = resolveWecomMergedMediaLocalRoots({
+      cfg: {
+        channels: {
+          wecom: {
+            media: {
+              localRoots: ["/tmp/agent-root", "/tmp/downloads"],
+            },
+          },
+        },
+      } as never,
+      baseRoots: ["/tmp/agent-root", "/tmp/workspace-agent"],
+    });
+
+    expect(roots).toEqual(
+      expect.arrayContaining([
+        path.resolve(resolvePreferredOpenClawTmpDir()),
+        "/tmp/wecom-state",
+        "/tmp/workspace-agent",
+        "/tmp/agent-root",
+        "/tmp/downloads",
+      ]),
+    );
+    expect(roots.filter((root) => root === "/tmp/agent-root")).toHaveLength(1);
+  });
+});
+
+describe("resolveWecomMediaMaxBytes", () => {
+  it("prefers account mediaMaxMb over channel and agent defaults", () => {
+    expect(
+      resolveWecomMediaMaxBytes(
+        {
+          agents: {
+            defaults: {
+              mediaMaxMb: 12,
+            },
+          },
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+              accounts: {
+                ops: {
+                  mediaMaxMb: 32,
+                },
+              },
+            },
+          },
+        } as never,
+        "ops",
+      ),
+    ).toBe(32 * 1024 * 1024);
+  });
+
+  it("falls back to legacy channels.wecom.media.maxBytes when mediaMaxMb is unset", () => {
+    expect(
+      resolveWecomMediaMaxBytes({
+        channels: {
+          wecom: {
+            media: {
+              maxBytes: 15 * 1024 * 1024,
+            },
+          },
+        },
+      } as never),
+    ).toBe(15 * 1024 * 1024);
+  });
+});

package/src/config/media.ts

@@ -1,14 +1,139 @@
+import os from "node:os";
+import path from "node:path";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
 
 // 默认给一个相对“够用”的上限（80MB），避免视频/较大文件频繁触发失败。
 // 仍保留上限以防止恶意大文件把进程内存打爆（下载实现会读入内存再保存）。
 export const DEFAULT_WECOM_MEDIA_MAX_BYTES = 80 * 1024 * 1024;
 
-export function resolveWecomMediaMaxBytes(cfg: OpenClawConfig): number {
+function parsePositiveNumber(value: unknown): number | undefined {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return undefined;
+  }
+  return parsed;
+}
+
+function resolveStateDirForWecomMedia(): string {
+  const stateOverride =
+    process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+  if (stateOverride) {
+    return stateOverride;
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+
+function normalizeWecomLocalRoot(root: string): string | undefined {
+  const trimmed = root.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  return path.resolve(trimmed.replace(/^~(?=\/|$)/, os.homedir()));
+}
+
+function getWecomCommonUserMediaLocalRoots(): readonly string[] {
+  const home = os.homedir();
+  return [
+    path.join(home, "Desktop"),
+    path.join(home, "Documents"),
+    path.join(home, "Downloads"),
+    path.join(home, "Movies"),
+    path.join(home, "Pictures"),
+  ];
+}
+
+export function getWecomDefaultMediaLocalRoots(): readonly string[] {
+  const stateDir = path.resolve(resolveStateDirForWecomMedia());
+  return [
+    path.resolve(resolvePreferredOpenClawTmpDir()),
+    stateDir,
+    path.join(stateDir, "media"),
+    path.join(stateDir, "agents"),
+    path.join(stateDir, "workspace"),
+    path.join(stateDir, "sandboxes"),
+    ...getWecomCommonUserMediaLocalRoots(),
+  ];
+}
+
+export function resolveWecomConfiguredMediaLocalRoots(cfg: OpenClawConfig): readonly string[] {
+  const rawWecom = cfg.channels?.wecom as
+    | {
+        media?: { localRoots?: unknown };
+        mediaLocalRoots?: unknown;
+      }
+    | undefined;
+  const configured = Array.isArray(rawWecom?.media?.localRoots)
+    ? rawWecom.media.localRoots
+    : Array.isArray(rawWecom?.mediaLocalRoots)
+      ? rawWecom.mediaLocalRoots
+      : [];
+  return configured
+    .filter((root): root is string => typeof root === "string")
+    .map(normalizeWecomLocalRoot)
+    .filter((root): root is string => Boolean(root));
+}
+
+export function resolveWecomMergedMediaLocalRoots(params: {
+  cfg: OpenClawConfig;
+  baseRoots?: readonly string[];
+}): readonly string[] {
+  const merged: string[] = [];
+  const seen = new Set<string>();
+  const pushRoot = (root: string) => {
+    const normalized = normalizeWecomLocalRoot(root);
+    if (!normalized || seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    merged.push(normalized);
+  };
+
+  for (const root of getWecomDefaultMediaLocalRoots()) {
+    pushRoot(root);
+  }
+  for (const root of params.baseRoots ?? []) {
+    pushRoot(root);
+  }
+  for (const root of resolveWecomConfiguredMediaLocalRoots(params.cfg)) {
+    pushRoot(root);
+  }
+  return merged;
+}
+
+function resolveLegacyWecomMediaMaxBytes(cfg: OpenClawConfig): number | undefined {
   const raw = (cfg.channels?.wecom as any)?.media?.maxBytes;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  if (Number.isFinite(n) && n > 0) {
-    return Math.floor(n);
+  const bytes = parsePositiveNumber(raw);
+  if (bytes) {
+    return Math.floor(bytes);
+  }
+  return undefined;
+}
+
+export function resolveWecomMediaMaxBytes(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): number {
+  const mediaMaxBytes = resolveChannelMediaMaxBytes({
+    cfg,
+    accountId,
+    resolveChannelLimitMb: ({ cfg, accountId }) => {
+      const wecom = cfg.channels?.wecom as
+        | {
+            mediaMaxMb?: unknown;
+            accounts?: Record<string, { mediaMaxMb?: unknown }>;
+          }
+        | undefined;
+      const accountLimitMb = parsePositiveNumber(wecom?.accounts?.[accountId]?.mediaMaxMb);
+      if (accountLimitMb) {
+        return accountLimitMb;
+      }
+      return parsePositiveNumber(wecom?.mediaMaxMb);
+    },
+  });
+  if (mediaMaxBytes) {
+    return mediaMaxBytes;
   }
-  return DEFAULT_WECOM_MEDIA_MAX_BYTES;
+  return resolveLegacyWecomMediaMaxBytes(cfg) ?? DEFAULT_WECOM_MEDIA_MAX_BYTES;
 }

package/src/config/schema.ts

@@ -8,6 +8,7 @@ export interface MediaConfig {
   retentionHours?: number;
   cleanupOnStart?: boolean;
   maxBytes?: number;
+  localRoots?: string[];
 }
 
 export interface NetworkConfig {
@@ -61,12 +62,14 @@ export interface DynamicAgentsConfig {
 export interface AccountConfig {
   enabled?: boolean;
   name?: string;
+  mediaMaxMb?: number;
   bot?: BotConfig;
   agent?: AgentConfig;
 }
 
 export interface WecomConfigInput {
   enabled?: boolean;
+  mediaMaxMb?: number;
   bot?: BotConfig;
   agent?: AgentConfig;
   accounts?: Record<string, AccountConfig>;

package/src/context-store.ts

@@ -0,0 +1,264 @@
+/**
+ * Context store for WeCom Bot WS proactive push.
+ *
+ * Similar to Weixin's contextToken mechanism, we need to track:
+ * - Which accountId has active sessions with which peerId
+ * - The contextToken for routing outbound messages
+ */
+
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+// Simple logger
+const logger = {
+  info: (...args: unknown[]) => console.log('[wecom-context]', ...args),
+  warn: (...args: unknown[]) => console.warn('[wecom-context]', ...args),
+  debug: (...args: unknown[]) => process.env.DEBUG && console.log('[wecom-context]', ...args),
+};
+
+type PeerKind = "direct" | "group";
+
+type StoredPeerContext = {
+  contextToken: string;
+  peerKind: PeerKind;
+  lastSeen: number;
+};
+
+type ResolvedPeerContext = StoredPeerContext & {
+  accountId: string;
+  peerId: string;
+};
+
+// In-memory store: accountId -> peerId -> context info
+const peerContextStore = new Map<string, Map<string, StoredPeerContext>>();
+
+// Reverse lookup: peerId -> accountId (for routing outbound)
+const peerToAccountMap = new Map<string, string>();
+const contextTokenToPeerMap = new Map<string, ResolvedPeerContext>();
+
+function resolveStateDir(): string {
+  return process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME || "/tmp", ".openclaw");
+}
+
+function resolveContextFilePath(accountId: string): string {
+  return path.join(
+    resolveStateDir(),
+    "wecom",
+    "context",
+    `${accountId}.json`
+  );
+}
+
+/** Persist peer contexts for an account to disk */
+function persistContexts(accountId: string): void {
+  const peerMap = peerContextStore.get(accountId);
+  if (!peerMap) return;
+
+  const data: Record<string, StoredPeerContext> = {};
+  for (const [peerId, info] of peerMap) {
+    data[peerId] = info;
+  }
+
+  const filePath = resolveContextFilePath(accountId);
+  try {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 0), "utf-8");
+  } catch (err) {
+    logger.warn?.(`persistContexts: failed to write ${filePath}: ${String(err)}`);
+  }
+}
+
+function normalizeContextToken(value: unknown): string | undefined {
+  const token = typeof value === "string" ? value.trim() : "";
+  return token || undefined;
+}
+
+function normalizePeerKind(value: unknown): PeerKind {
+  return value === "group" ? "group" : "direct";
+}
+
+function registerPeerContext(accountId: string, peerId: string, info: StoredPeerContext): void {
+  let peerMap = peerContextStore.get(accountId);
+  if (!peerMap) {
+    peerMap = new Map();
+    peerContextStore.set(accountId, peerMap);
+  }
+
+  const previous = peerMap.get(peerId);
+  if (previous?.contextToken && previous.contextToken !== info.contextToken) {
+    contextTokenToPeerMap.delete(previous.contextToken);
+  }
+
+  peerMap.set(peerId, info);
+  peerToAccountMap.set(peerId, accountId);
+  contextTokenToPeerMap.set(info.contextToken, {
+    accountId,
+    peerId,
+    ...info,
+  });
+}
+
+function resolveStoredPeerContext(
+  accountId: string,
+  peerId: string,
+  params: {
+    contextToken?: string;
+    peerKind?: PeerKind;
+    lastSeen?: number;
+  },
+): StoredPeerContext {
+  const existing = peerContextStore.get(accountId)?.get(peerId);
+  return {
+    contextToken:
+      normalizeContextToken(params.contextToken) ??
+      existing?.contextToken ??
+      randomUUID(),
+    peerKind: params.peerKind ?? existing?.peerKind ?? "direct",
+    lastSeen: params.lastSeen ?? Date.now(),
+  };
+}
+
+/** Restore persisted peer contexts for an account */
+export function restorePeerContexts(accountId: string): void {
+  const filePath = resolveContextFilePath(accountId);
+  try {
+    if (!fs.existsSync(filePath)) return;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw) as Record<
+      string,
+      {
+        contextToken?: string;
+        peerKind?: string;
+        lastSeen?: number;
+      }
+    >;
+
+    const peerMap = new Map<string, StoredPeerContext>();
+    let count = 0;
+    let mutated = false;
+    for (const [peerId, info] of Object.entries(data)) {
+      const normalized: StoredPeerContext = {
+        contextToken: normalizeContextToken(info?.contextToken) ?? randomUUID(),
+        peerKind: normalizePeerKind(info?.peerKind),
+        lastSeen:
+          typeof info?.lastSeen === "number" && Number.isFinite(info.lastSeen)
+            ? info.lastSeen
+            : Date.now(),
+      };
+      peerMap.set(peerId, normalized);
+      peerToAccountMap.set(peerId, accountId);
+      contextTokenToPeerMap.set(normalized.contextToken, {
+        accountId,
+        peerId,
+        ...normalized,
+      });
+      if (
+        normalized.contextToken !== info?.contextToken ||
+        normalized.peerKind !== info?.peerKind ||
+        normalized.lastSeen !== info?.lastSeen
+      ) {
+        mutated = true;
+      }
+      count++;
+    }
+    peerContextStore.set(accountId, peerMap);
+    if (mutated) {
+      persistContexts(accountId);
+    }
+    logger.info?.(`restorePeerContexts: restored ${count} peers for account=${accountId}`);
+  } catch (err) {
+    logger.warn?.(`restorePeerContexts: failed to read ${filePath}: ${String(err)}`);
+  }
+}
+
+/** Store context for a peer (called on inbound message) */
+export function setPeerContext(
+  accountId: string,
+  peerId: string,
+  options?: {
+    contextToken?: string;
+    peerKind?: PeerKind;
+    lastSeen?: number;
+  },
+): string {
+  const resolved = resolveStoredPeerContext(accountId, peerId, options ?? {});
+  registerPeerContext(accountId, peerId, resolved);
+
+  // Persist to disk (debounced would be better, but simple for now)
+  persistContexts(accountId);
+
+  logger.debug?.(
+    `setPeerContext: accountId=${accountId} peerId=${peerId} token=${resolved.contextToken} kind=${resolved.peerKind}`,
+  );
+  return resolved.contextToken;
+}
+
+/** Get the accountId that has an active session with a peer */
+export function getAccountIdByPeer(peerId: string): string | undefined {
+  return peerToAccountMap.get(peerId);
+}
+
+/** Get the most recent peerId for an account (for proactive push) */
+export function getRecentPeerForAccount(accountId: string, maxAgeMs = 30 * 60 * 1000): string | undefined {
+  const peerMap = peerContextStore.get(accountId);
+  if (!peerMap) return undefined;
+
+  let mostRecent: { peerId: string; lastSeen: number } | undefined;
+
+  for (const [peerId, info] of peerMap) {
+    if (Date.now() - info.lastSeen > maxAgeMs) continue;
+    if (!mostRecent || info.lastSeen > mostRecent.lastSeen) {
+      mostRecent = { peerId, lastSeen: info.lastSeen };
+    }
+  }
+
+  return mostRecent?.peerId;
+}
+
+/** Get context token for a peer */
+export function getPeerContextToken(accountId: string, peerId: string): string | undefined {
+  const peerMap = peerContextStore.get(accountId);
+  return peerMap?.get(peerId)?.contextToken;
+}
+
+/** Resolve a peer context from a context token. */
+export function getPeerContextByToken(contextToken: string): ResolvedPeerContext | undefined {
+  return contextTokenToPeerMap.get(contextToken);
+}
+
+/** Resolve accountId from a context token. */
+export function getAccountIdByContextToken(contextToken: string): string | undefined {
+  return contextTokenToPeerMap.get(contextToken)?.accountId;
+}
+
+/** Check if we have an active session for routing */
+export function hasActiveSession(accountId: string, peerId: string, maxAgeMs = 30 * 60 * 1000): boolean {
+  const peerMap = peerContextStore.get(accountId);
+  if (!peerMap) return false;
+
+  const info = peerMap.get(peerId);
+  if (!info) return false;
+
+  return Date.now() - info.lastSeen < maxAgeMs;
+}
+
+/** Clear all contexts for an account */
+export function clearPeerContexts(accountId: string): void {
+  const peerMap = peerContextStore.get(accountId);
+  if (peerMap) {
+    for (const [peerId, info] of peerMap) {
+      peerToAccountMap.delete(peerId);
+      contextTokenToPeerMap.delete(info.contextToken);
+    }
+  }
+  peerContextStore.delete(accountId);
+
+  const filePath = resolveContextFilePath(accountId);
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  } catch (err) {
+    logger.warn?.(`clearPeerContexts: failed to remove ${filePath}`);
+  }
+}

package/src/onboarding.ts

@@ -8,7 +8,7 @@ import type {
     OpenClawConfig,
     WizardPrompter,
 } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { listWecomAccountIds, resolveDefaultWecomAccountId, resolveWecomAccount, resolveWecomAccounts } from "./config/index.js";
 import type { WecomConfig, WecomBotConfig, WecomAgentConfig, WecomDmConfig, WecomAccountConfig } from "./types/index.js";