@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/channel.config.test.ts

@@ -1,180 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { describe, expect, it } from "vitest";
-
-import { wecomPlugin } from "./channel.js";
-import { resolveWecomAccounts } from "./config/accounts.js";
-
-describe("wecomPlugin config.deleteAccount", () => {
-  it("removes only the target matrix account", () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: {
-                token: "token-a",
-                encodingAESKey: "aes-a",
-              },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: {
-                token: "token-b",
-                encodingAESKey: "aes-b",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const next = wecomPlugin.config.deleteAccount!({ cfg, accountId: "acct-a" });
-    const accounts = (next.channels?.wecom as { accounts?: Record<string, unknown> } | undefined)
-      ?.accounts;
-
-    expect(accounts?.["acct-a"]).toBeUndefined();
-    expect(accounts?.["acct-b"]).toBeDefined();
-    expect(next.channels?.wecom).toBeDefined();
-  });
-
-  it("removes legacy wecom section when deleting default account", () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          bot: {
-            token: "token",
-            encodingAESKey: "aes",
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const next = wecomPlugin.config.deleteAccount!({ cfg, accountId: "default" });
-    expect(next.channels?.wecom).toBeUndefined();
-  });
-});
-
-describe("wecomPlugin account conflict guards", () => {
-  it("marks duplicate bot token account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: { token: "token-shared", encodingAESKey: "aes-a" },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: { token: "token-shared", encodingAESKey: "aes-b" },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountA = wecomPlugin.config.resolveAccount(cfg, "acct-a");
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountA, cfg)).toBe(true);
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain("Duplicate WeCom bot token");
-  });
-
-  it("marks duplicate bot aibotid account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: { token: "token-a", encodingAESKey: "aes-a", aibotid: "BOT_001" },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: { token: "token-b", encodingAESKey: "aes-b", aibotid: "BOT_001" },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain("Duplicate WeCom bot aibotid");
-  });
-
-  it("marks duplicate corpId/agentId account as unconfigured", async () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              agent: {
-                corpId: "corp-1",
-                corpSecret: "secret-a",
-                agentId: 1001,
-                token: "token-a",
-                encodingAESKey: "aes-a",
-              },
-            },
-            "acct-b": {
-              enabled: true,
-              agent: {
-                corpId: "corp-1",
-                corpSecret: "secret-b",
-                agentId: 1001,
-                token: "token-b",
-                encodingAESKey: "aes-b",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const accountB = wecomPlugin.config.resolveAccount(cfg, "acct-b");
-    expect(await wecomPlugin.config.isConfigured!(accountB, cfg)).toBe(false);
-    expect(wecomPlugin.config.unconfiguredReason?.(accountB, cfg)).toContain(
-      "Duplicate WeCom agent identity",
-    );
-  });
-
-  it("normalizes agent inbound event policy on resolved accounts", () => {
-    const cfg: OpenClawConfig = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            default: {
-              enabled: true,
-              agent: {
-                corpId: "corp-1",
-                corpSecret: "secret-a",
-                agentId: 1001,
-                token: "token-a",
-                encodingAESKey: "aes-a",
-                inboundPolicy: {
-                  eventEnabled: true,
-                  eventPolicy: {
-                    allowedEventTypes: [" Click ", "view", "click"],
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    const resolved = resolveWecomAccounts(cfg);
-    expect(resolved.accounts.default?.agent?.eventEnabled).toBe(true);
-    expect(resolved.accounts.default?.agent?.allowedEventTypes).toEqual(["click", "view"]);
-  });
-});

package/src/channel.lifecycle.test.ts

@@ -1,255 +0,0 @@
-import { IncomingMessage, ServerResponse } from "node:http";
-import { Socket } from "node:net";
-
-import {
-  type ChannelAccountSnapshot,
-  type ChannelGatewayContext,
-  type OpenClawConfig,
-} from "openclaw/plugin-sdk";
-import { describe, expect, it, vi } from "vitest";
-
-import { createRuntimeEnv } from "../../test-utils/runtime-env.js";
-import { computeWecomMsgSignature, encryptWecomPlaintext } from "./crypto.js";
-import { wecomPlugin } from "./channel.js";
-import { handleWecomWebhookRequest } from "./monitor.js";
-import type { ResolvedWecomAccount } from "./types/index.js";
-
-function createMockRequest(params: {
-  method: "GET" | "POST";
-  url: string;
-  body?: unknown;
-}): IncomingMessage {
-  const socket = new Socket();
-  const req = new IncomingMessage(socket);
-  req.method = params.method;
-  req.url = params.url;
-  if (params.method === "POST") {
-    req.push(JSON.stringify(params.body ?? {}));
-  }
-  req.push(null);
-  return req;
-}
-
-function createMockResponse(): ServerResponse & {
-  _getData: () => string;
-  _getStatusCode: () => number;
-} {
-  type MockResponse = ServerResponse & {
-    _getData: () => string;
-    _getStatusCode: () => number;
-  };
-  const req = new IncomingMessage(new Socket());
-  const res = new ServerResponse(req) as MockResponse;
-  let data = "";
-  res.write = (chunk: string | Uint8Array) => {
-    data += String(chunk);
-    return true;
-  };
-  res.end = ((chunk?: string | Uint8Array) => {
-    if (chunk) data += String(chunk);
-    return res;
-  }) as MockResponse["end"];
-  res._getData = () => data;
-  res._getStatusCode = () => res.statusCode;
-  return res;
-}
-
-function createCtx(params: {
-  cfg: OpenClawConfig;
-  accountId?: string;
-  abortController: AbortController;
-}): ChannelGatewayContext<ResolvedWecomAccount> & {
-  statusUpdates: Array<Partial<ChannelAccountSnapshot>>;
-} {
-  const accountId = params.accountId ?? "default";
-  const account = wecomPlugin.config.resolveAccount(
-    params.cfg,
-    accountId,
-  ) as ResolvedWecomAccount;
-  const snapshot: ChannelAccountSnapshot = {
-    accountId,
-    configured: true,
-    enabled: true,
-    running: false,
-  };
-  const statusUpdates: Array<Partial<ChannelAccountSnapshot>> = [];
-  return {
-    cfg: params.cfg,
-    accountId,
-    account,
-    runtime: createRuntimeEnv(),
-    abortSignal: params.abortController.signal,
-    log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-    getStatus: () => snapshot,
-    setStatus: (next) => {
-      statusUpdates.push(next);
-      Object.assign(snapshot, next);
-    },
-    statusUpdates,
-  };
-}
-
-function createWebhookBotConfig(params: {
-  token: string;
-  encodingAESKey: string;
-  receiveId?: string;
-}): OpenClawConfig {
-  return {
-    channels: {
-      wecom: {
-        enabled: true,
-        bot: {
-          primaryTransport: "webhook",
-          webhook: {
-            token: params.token,
-            encodingAESKey: params.encodingAESKey,
-            receiveId: params.receiveId ?? "",
-          },
-        },
-      },
-    },
-  } as OpenClawConfig;
-}
-
-async function sendWecomGetVerify(params: {
-  path: string;
-  token: string;
-  encodingAESKey: string;
-  receiveId: string;
-}): Promise<{ handled: boolean; status: number; body: string }> {
-  const timestamp = "1700000000";
-  const nonce = "nonce";
-  const echostr = encryptWecomPlaintext({
-    encodingAESKey: params.encodingAESKey,
-    receiveId: params.receiveId,
-    plaintext: "ping",
-  });
-  const msgSignature = computeWecomMsgSignature({
-    token: params.token,
-    timestamp,
-    nonce,
-    encrypt: echostr,
-  });
-  const req = createMockRequest({
-    method: "GET",
-    url:
-      `${params.path}?msg_signature=${encodeURIComponent(msgSignature)}` +
-      `&timestamp=${encodeURIComponent(timestamp)}` +
-      `&nonce=${encodeURIComponent(nonce)}` +
-      `&echostr=${encodeURIComponent(echostr)}`,
-  });
-  const res = createMockResponse();
-  const handled = await handleWecomWebhookRequest(req, res);
-  return {
-    handled,
-    status: res._getStatusCode(),
-    body: res._getData(),
-  };
-}
-
-describe("wecomPlugin gateway lifecycle", () => {
-  it("keeps startAccount pending until abort signal", async () => {
-    const token = "token";
-    const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
-    const cfg = createWebhookBotConfig({ token, encodingAESKey });
-    const abortController = new AbortController();
-    const ctx = createCtx({ cfg, abortController });
-
-    const startPromise = wecomPlugin.gateway!.startAccount!(ctx);
-    let resolved = false;
-    void startPromise.then(() => {
-      resolved = true;
-    });
-
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(resolved).toBe(false);
-
-    abortController.abort();
-    await startPromise;
-    expect(resolved).toBe(true);
-  });
-
-  it("unregisters webhook targets after abort", async () => {
-    const token = "token";
-    const encodingAESKey = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG";
-    const receiveId = "";
-    const cfg = createWebhookBotConfig({ token, encodingAESKey, receiveId });
-    const abortController = new AbortController();
-    const ctx = createCtx({ cfg, abortController });
-
-    const startPromise = wecomPlugin.gateway!.startAccount!(ctx);
-    await Promise.resolve();
-
-    const activeLegacyRoute = await sendWecomGetVerify({
-      path: "/wecom/bot",
-      token,
-      encodingAESKey,
-      receiveId,
-    });
-    expect(activeLegacyRoute.handled).toBe(true);
-    expect(activeLegacyRoute.status).toBe(200);
-    expect(activeLegacyRoute.body).toBe("ping");
-
-    const activePluginRoute = await sendWecomGetVerify({
-      path: "/plugins/wecom/bot",
-      token,
-      encodingAESKey,
-      receiveId,
-    });
-    expect(activePluginRoute.handled).toBe(true);
-    expect(activePluginRoute.status).toBe(200);
-    expect(activePluginRoute.body).toBe("ping");
-
-    abortController.abort();
-    await startPromise;
-
-    const inactiveLegacyRoute = await sendWecomGetVerify({
-      path: "/wecom/bot",
-      token,
-      encodingAESKey,
-      receiveId,
-    });
-    expect(inactiveLegacyRoute.handled).toBe(false);
-
-    const inactivePluginRoute = await sendWecomGetVerify({
-      path: "/plugins/wecom/bot",
-      token,
-      encodingAESKey,
-      receiveId,
-    });
-    expect(inactivePluginRoute.handled).toBe(false);
-  });
-
-  it("rejects startup when matrix account credentials conflict", async () => {
-    const cfg = {
-      channels: {
-        wecom: {
-          enabled: true,
-          accounts: {
-            "acct-a": {
-              enabled: true,
-              bot: {
-                token: "token-shared",
-                encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
-              },
-            },
-            "acct-b": {
-              enabled: true,
-              bot: {
-                token: "token-shared",
-                encodingAESKey: "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFG",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-    const abortController = new AbortController();
-    const ctx = createCtx({ cfg, accountId: "acct-b", abortController });
-
-    await expect(wecomPlugin.gateway!.startAccount!(ctx)).rejects.toThrow(
-      /Duplicate WeCom bot token/i,
-    );
-  });
-});

package/src/channel.meta.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { wecomPlugin } from "./channel.js";
-
-describe("wecomPlugin meta", () => {
-  it("uses chinese-facing labels in channel selection", () => {
-    expect(wecomPlugin.meta.label).toBe("WeCom (企业微信)");
-    expect(wecomPlugin.meta.selectionLabel).toBe("WeCom (企业微信)");
-    expect(wecomPlugin.meta.blurb).toContain("企业微信官方推荐三方插件");
-    expect(wecomPlugin.meta.docsLabel).toBe("企业微信");
-    expect(wecomPlugin.meta.selectionDocsPrefix).toBe("文档：");
-  });
-
-  it("exposes a setupWizard for guided setup discovery", () => {
-    expect(wecomPlugin.setupWizard?.channel).toBe("wecom");
-  });
-
-  it("preserves fully qualified WeCom messaging targets during normalization", () => {
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom:user:zhangsan")).toBe(
-      "wecom:user:zhangsan",
-    );
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom-agent:blue:user:zhangsan")).toBe(
-      "wecom-agent:blue:user:zhangsan",
-    );
-    expect(wecomPlugin.messaging?.normalizeTarget?.("wecom:zhangsan")).toBe("zhangsan");
-  });
-});