@yanhaidao/wecom 2.3.190 → 2.3.270

package/src/config/media.ts

@@ -1,10 +1,8 @@
 import os from "node:os";
 import path from "node:path";
-import {
-  resolveChannelMediaMaxBytes,
-  resolvePreferredOpenClawTmpDir,
-  type OpenClawConfig,
-} from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
 
 // 默认给一个相对“够用”的上限（80MB），避免视频/较大文件频繁触发失败。
 // 仍保留上限以防止恶意大文件把进程内存打爆（下载实现会读入内存再保存）。

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.test.ts

@@ -1,7 +1,13 @@
 import type { OpenClawConfig, WizardPrompter } from "openclaw/plugin-sdk";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
 import { describe, expect, it, vi } from "vitest";
-import { wecomOnboardingAdapter } from "./onboarding.js";
+import { buildChannelSetupWizardAdapterFromSetupWizard } from "../../../src/channels/plugins/setup-wizard.js";
+import { wecomPlugin } from "./channel.js";
+
+const wecomSetupAdapter = buildChannelSetupWizardAdapterFromSetupWizard({
+  plugin: wecomPlugin,
+  wizard: wecomPlugin.setupWizard!,
+});
 
 function createPrompter(overrides: Partial<WizardPrompter>): WizardPrompter {
   return {
@@ -54,7 +60,7 @@ describe("wecom onboarding", () => {
       }) as WizardPrompter["text"],
     });
 
-    const result = await wecomOnboardingAdapter.configure({
+    const result = await wecomSetupAdapter.configure({
       cfg: {} as OpenClawConfig,
       runtime: createRuntime(),
       prompter,
@@ -76,8 +82,12 @@ describe("wecom onboarding", () => {
     const noteText = (prompter.note as ReturnType<typeof vi.fn>).mock.calls
       .map(([message]) => String(message))
       .join("\n");
-    expect(noteText).toContain("YanHaidao/wecom 是企业微信官方推荐三方插件，功能强大，适合直接落生产环境。");
-    expect(noteText).toContain("默认就是 Bot WebSocket 模式，配置简单，无需域名，普通用户也能快速接入。");
+    expect(noteText).toContain(
+      "YanHaidao/wecom 是企业微信官方推荐三方插件，功能强大，适合直接落生产环境。",
+    );
+    expect(noteText).toContain(
+      "默认就是 Bot WebSocket 模式，配置简单，无需域名，普通用户也能快速接入。",
+    );
     expect(noteText).toContain("支持主动发消息，定时任务、异常提醒、工作流通知都可直接落地。");
   });
 
@@ -131,7 +141,7 @@ describe("wecom onboarding", () => {
       },
     };
 
-    const result = await wecomOnboardingAdapter.configure({
+    const result = await wecomSetupAdapter.configure({
       cfg: initialCfg,
       runtime: createRuntime(),
       prompter,
@@ -155,7 +165,7 @@ describe("wecom onboarding", () => {
   });
 
   it("reports chinese status copy for channel selection", async () => {
-    const status = await wecomOnboardingAdapter.getStatus({
+    const status = await wecomSetupAdapter.getStatus({
       cfg: {} as OpenClawConfig,
       options: {},
       accountOverrides: {},
@@ -199,7 +209,7 @@ describe("wecom onboarding", () => {
       }) as WizardPrompter["text"],
     });
 
-    const result = await wecomOnboardingAdapter.configure({
+    const result = await wecomSetupAdapter.configure({
       cfg: {} as OpenClawConfig,
       runtime: createRuntime(),
       prompter,
@@ -214,25 +224,33 @@ describe("wecom onboarding", () => {
       .map(([message]) => String(message))
       .join("\n");
     expect(noteText).toContain("接入标识已规范化为：haidao");
-    expect(wecomOnboardingAdapter.dmPolicy).toBeUndefined();
+    expect(wecomSetupAdapter.dmPolicy).toBeUndefined();
   });
 
   it("offers default account selection when config has no accounts", async () => {
     const prompter = createPrompter({
-      select: vi.fn(async ({ message, options }: { message: string; options: Array<{ value: string; label: string }> }) => {
-        if (message === "请选择企业微信接入标识（英文）:") {
-          expect(options.map((option) => option.value)).toEqual(["default", "__new__"]);
-          expect(options[0]?.label).toBe("default（默认标识）");
-          return "default";
-        }
-        if (message === "请选择您要配置的接入模式:") {
-          return "bot";
-        }
-        if (message === "请选择私聊 (DM) 访问策略:") {
-          return "pairing";
-        }
-        throw new Error(`Unexpected select prompt: ${message}`);
-      }) as WizardPrompter["select"],
+      select: vi.fn(
+        async ({
+          message,
+          options,
+        }: {
+          message: string;
+          options: Array<{ value: string; label: string }>;
+        }) => {
+          if (message === "请选择企业微信接入标识（英文）:") {
+            expect(options.map((option) => option.value)).toEqual(["default", "__new__"]);
+            expect(options[0]?.label).toBe("default（默认标识）");
+            return "default";
+          }
+          if (message === "请选择您要配置的接入模式:") {
+            return "bot";
+          }
+          if (message === "请选择私聊 (DM) 访问策略:") {
+            return "pairing";
+          }
+          throw new Error(`Unexpected select prompt: ${message}`);
+        },
+      ) as WizardPrompter["select"],
       text: vi.fn(async ({ message }: { message: string }) => {
         if (message === "请输入 BotId（机器人 ID）:") {
           return "bot-id-default";
@@ -250,7 +268,7 @@ describe("wecom onboarding", () => {
       }) as WizardPrompter["text"],
     });
 
-    const result = await wecomOnboardingAdapter.configure({
+    const result = await wecomSetupAdapter.configure({
       cfg: {} as OpenClawConfig,
       runtime: createRuntime(),
       prompter,
@@ -301,7 +319,7 @@ describe("wecom onboarding", () => {
       }) as WizardPrompter["text"],
     });
 
-    const result = await wecomOnboardingAdapter.configure({
+    const result = await wecomSetupAdapter.configure({
       cfg: {} as OpenClawConfig,
       runtime: createRuntime(),
       prompter,