@elizaos/plugin-wechat 2.0.0-alpha.537 → 2.0.3-beta.5

package/src/channel.test.ts

@@ -1,121 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { WechatChannel } from "./channel";
-import type { WechatMessageContext } from "./types";
-
-function createConfig() {
-  return {
-    accounts: {
-      main: {
-        apiKey: "main-key",
-        proxyUrl: "https://proxy.example.com",
-      },
-      secondary: {
-        apiKey: "secondary-key",
-        proxyUrl: "https://proxy.example.com",
-      },
-    },
-  };
-}
-
-function createMessage(
-  overrides: Partial<WechatMessageContext> = {},
-): WechatMessageContext {
-  return {
-    id: "wechat-msg-1",
-    type: "text",
-    sender: "wxid-alice",
-    recipient: "wxid-agent",
-    content: "hello agent",
-    timestamp: 123,
-    raw: {},
-    ...overrides,
-  };
-}
-
-afterEach(() => {
-  vi.useRealTimers();
-  vi.restoreAllMocks();
-});
-
-describe("WechatChannel", () => {
-  it("routes inbound messages to the matching account bot", () => {
-    const channel = new WechatChannel({
-      config: createConfig(),
-      onMessage: vi.fn(),
-    });
-    const mainBot = { handleIncoming: vi.fn(), stop: vi.fn() };
-    const secondaryBot = { handleIncoming: vi.fn(), stop: vi.fn() };
-
-    (
-      channel as unknown as {
-        accounts: Map<
-          string,
-          { client: object; dispatcher: object; bot: typeof mainBot }
-        >;
-        routeIncoming: (accountId: string, msg: WechatMessageContext) => void;
-      }
-    ).accounts.set("main", {
-      client: {},
-      dispatcher: {},
-      bot: mainBot,
-    });
-    (
-      channel as unknown as {
-        accounts: Map<
-          string,
-          { client: object; dispatcher: object; bot: typeof secondaryBot }
-        >;
-      }
-    ).accounts.set("secondary", {
-      client: {},
-      dispatcher: {},
-      bot: secondaryBot,
-    });
-
-    (
-      channel as unknown as {
-        routeIncoming: (accountId: string, msg: WechatMessageContext) => void;
-      }
-    ).routeIncoming("secondary", createMessage());
-
-    expect(mainBot.handleIncoming).not.toHaveBeenCalled();
-    expect(secondaryBot.handleIncoming).toHaveBeenCalledWith(
-      expect.objectContaining({ id: "wechat-msg-1" }),
-    );
-  });
-
-  it("times out login when QR verification never completes", async () => {
-    vi.useFakeTimers();
-    vi.spyOn(console, "log").mockImplementation(() => undefined);
-
-    const channel = new WechatChannel({
-      config: createConfig(),
-      onMessage: vi.fn(),
-    });
-    const client = {
-      getStatus: vi.fn().mockResolvedValue({
-        valid: true,
-        loginState: "waiting",
-      }),
-      getQRCode: vi.fn().mockResolvedValue("https://proxy.example.com/qr"),
-      checkLogin: vi.fn().mockResolvedValue({ status: "waiting" }),
-    };
-
-    (
-      channel as unknown as { abortController: AbortController | null }
-    ).abortController = new AbortController();
-
-    const loginPromise = (
-      channel as unknown as {
-        ensureLoggedIn: (
-          accountId: string,
-          client: typeof client,
-        ) => Promise<void>;
-      }
-    ).ensureLoggedIn("main", client);
-    const rejection = expect(loginPromise).rejects.toThrow(/timed out/i);
-
-    await vi.advanceTimersByTimeAsync(5 * 60_000 + 5_000);
-    await rejection;
-  });
-});

package/src/proxy-client-429.test.ts

@@ -1,24 +0,0 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-describe("proxy-client 429 body consumption", () => {
-  it("consumes response body before retry on 429", () => {
-    const source = readFileSync(
-      path.join(__dirname, "proxy-client.ts"),
-      "utf-8",
-    );
-
-    const idx = source.indexOf("res.status === 429");
-    expect(idx).toBeGreaterThan(-1);
-
-    const block = source.slice(idx, idx + 500);
-    expect(block).toContain("res.text()");
-    expect(block.indexOf("res.text()")).toBeLessThan(
-      block.indexOf("continue;"),
-    );
-  });
-});

package/src/proxy-client.test.ts

@@ -1,46 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { ProxyClient } from "./proxy-client";
-
-describe("ProxyClient", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("rejects insecure proxy URLs", () => {
-    expect(
-      () =>
-        new ProxyClient({
-          id: "main",
-          apiKey: "main-key",
-          proxyUrl: "http://127.0.0.1:8787",
-          deviceType: "ipad",
-          webhookPort: 18790,
-        }),
-    ).toThrow("proxyUrl must use https://");
-  });
-
-  it("sends X-Device-Type header in requests", async () => {
-    const client = new ProxyClient({
-      id: "test-account",
-      apiKey: "test-key",
-      proxyUrl: "https://proxy.example.com",
-      deviceType: "mac",
-      webhookPort: 18790,
-    });
-
-    let capturedHeaders: Record<string, string> = {};
-    vi.spyOn(globalThis, "fetch").mockImplementation(async (_url, init) => {
-      capturedHeaders = (init?.headers ?? {}) as Record<string, string>;
-      return new Response(
-        JSON.stringify({ code: 1000, data: { status: "logged_in" } }),
-        { status: 200, headers: { "content-type": "application/json" } },
-      );
-    });
-
-    await client.getStatus();
-
-    expect(capturedHeaders["X-Device-Type"]).toBe("mac");
-    expect(capturedHeaders["X-Account-ID"]).toBe("test-account");
-    expect(capturedHeaders["X-API-Key"]).toBe("test-key");
-  });
-});

package/src/runtime-bridge.test.ts

@@ -1,135 +0,0 @@
-import type { Content } from "@elizaos/core";
-import { describe, expect, it, vi } from "vitest";
-import { deliverIncomingWechatMessage } from "./runtime-bridge";
-import type { WechatMessageContext } from "./types";
-
-function createMessage(
-  overrides: Partial<WechatMessageContext> = {},
-): WechatMessageContext {
-  return {
-    id: "wechat-msg-1",
-    type: "text",
-    sender: "wxid-alice",
-    recipient: "wxid-agent",
-    content: "hello agent",
-    timestamp: 123,
-    raw: { type: 60001 },
-    ...overrides,
-  };
-}
-
-function createRuntime(overrides: Record<string, unknown> = {}) {
-  return {
-    agentId: "00000000-0000-0000-0000-000000000001",
-    ensureConnection: vi.fn().mockResolvedValue(undefined),
-    createMemory: vi.fn().mockResolvedValue(undefined),
-    emitEvent: vi.fn().mockResolvedValue(undefined),
-    logger: {
-      warn: vi.fn(),
-      error: vi.fn(),
-    },
-    ...overrides,
-  };
-}
-
-describe("deliverIncomingWechatMessage", () => {
-  it("routes incoming messages through the runtime message API and reply callback", async () => {
-    const sendText = vi.fn().mockResolvedValue(undefined);
-    const sendMessage = vi.fn(
-      async (
-        _runtime: unknown,
-        _memory: unknown,
-        options?: {
-          onResponse?: (content: Content) => Promise<unknown>;
-        },
-      ) => {
-        await options?.onResponse?.({ text: "reply from agent" } as Content);
-        return { responseContent: { text: "reply from agent" } as Content };
-      },
-    );
-    const runtime = createRuntime({
-      elizaOS: { sendMessage },
-    });
-
-    await deliverIncomingWechatMessage({
-      runtime,
-      accountId: "main",
-      message: createMessage(),
-      sendText,
-    });
-
-    expect(runtime.ensureConnection).toHaveBeenCalledWith(
-      expect.objectContaining({
-        entityId: expect.any(String),
-        roomId: expect.any(String),
-        userName: "wxid-alice",
-        userId: "wxid-alice",
-        source: "wechat",
-        channelId: "wxid-alice",
-        worldName: "WeChat",
-      }),
-    );
-    expect(sendMessage).toHaveBeenCalledTimes(1);
-
-    const [, memory] = sendMessage.mock.calls[0];
-    expect(memory).toEqual(
-      expect.objectContaining({
-        content: expect.objectContaining({
-          text: "hello agent",
-          source: "wechat",
-          channelType: "DM",
-        }),
-        metadata: expect.objectContaining({
-          type: "message",
-          source: "wechat",
-          provider: "wechat",
-          fromId: "wxid-alice",
-          wechat: expect.objectContaining({
-            userId: "wxid-alice",
-            messageId: "wechat-msg-1",
-          }),
-        }),
-      }),
-    );
-
-    expect(sendText).toHaveBeenCalledTimes(1);
-    expect(sendText).toHaveBeenCalledWith(
-      "main",
-      "wxid-alice",
-      "reply from agent",
-    );
-    expect(runtime.createMemory).toHaveBeenCalledWith(
-      expect.objectContaining({
-        content: expect.objectContaining({
-          text: "reply from agent",
-          source: "wechat",
-          channelType: "DM",
-        }),
-      }),
-      "messages",
-    );
-  });
-
-  it("falls back to MESSAGE_RECEIVED events when no message pipeline is available", async () => {
-    const runtime = createRuntime();
-
-    await deliverIncomingWechatMessage({
-      runtime,
-      accountId: "main",
-      message: createMessage(),
-      sendText: vi.fn().mockResolvedValue(undefined),
-    });
-
-    expect(runtime.emitEvent).toHaveBeenCalledWith(["MESSAGE_RECEIVED"], {
-      runtime,
-      message: expect.objectContaining({
-        content: expect.objectContaining({
-          text: "hello agent",
-          source: "wechat",
-        }),
-      }),
-      callback: expect.any(Function),
-      source: "wechat",
-    });
-  });
-});