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

package/dist/runtime-bridge.js

@@ -1,159 +0,0 @@
-import { stringToUuid } from "@elizaos/core";
-
-//#region src/runtime-bridge.ts
-async function deliverIncomingWechatMessage(options) {
-	const runtime = options.runtime;
-	const agentId = typeof runtime.agentId === "string" && runtime.agentId.length > 0 ? runtime.agentId : stringToUuid("wechat-agent");
-	const incomingMemory = buildIncomingMemory(agentId, options.accountId, options.message);
-	const replyTarget = resolveReplyTarget(options.message);
-	let replyIndex = 0;
-	let replyDelivered = false;
-	const onResponse = async (content) => {
-		const replyText = extractReplyText(content);
-		if (!replyText) return [];
-		replyDelivered = true;
-		await options.sendText(options.accountId, replyTarget, replyText);
-		const replyMemory = buildReplyMemory(agentId, options.accountId, options.message, replyText, replyIndex);
-		replyIndex += 1;
-		await runtime.createMemory?.(replyMemory, "messages");
-		return [replyMemory];
-	};
-	await runtime.ensureConnection?.({
-		entityId: incomingMemory.entityId,
-		roomId: incomingMemory.roomId,
-		worldId: stringToUuid(`wechat:world:${options.accountId}`),
-		userName: options.message.sender,
-		userId: options.message.sender,
-		name: options.message.sender,
-		source: "wechat",
-		type: getChannelType(options.message),
-		channelId: resolveChannelId(options.message),
-		worldName: "WeChat"
-	});
-	if (typeof runtime.elizaOS?.sendMessage === "function") {
-		await maybeHandleResponseContent(await runtime.elizaOS.sendMessage(options.runtime, incomingMemory, { onResponse }), replyDelivered, onResponse);
-		return;
-	}
-	if (typeof runtime.messageService?.handleMessage === "function") {
-		await maybeHandleResponseContent(await runtime.messageService.handleMessage(options.runtime, incomingMemory, onResponse), replyDelivered, onResponse);
-		return;
-	}
-	if (typeof runtime.emitEvent === "function") {
-		await runtime.emitEvent(["MESSAGE_RECEIVED"], {
-			runtime: options.runtime,
-			message: incomingMemory,
-			callback: onResponse,
-			source: "wechat"
-		});
-		return;
-	}
-	runtime.logger?.warn?.("[wechat] No inbound runtime message pipeline is available");
-}
-function buildIncomingMemory(agentId, accountId, message) {
-	return {
-		id: stringToUuid(`wechat:incoming:${accountId}:${message.id}`),
-		agentId,
-		entityId: stringToUuid(`wechat:entity:${accountId}:${message.sender}`),
-		roomId: stringToUuid(`wechat:room:${accountId}:${resolveChannelId(message)}`),
-		createdAt: message.timestamp,
-		content: {
-			text: message.content,
-			source: "wechat",
-			channelType: getChannelType(message),
-			metadata: {
-				accountId,
-				sender: message.sender,
-				recipient: message.recipient,
-				messageType: message.type,
-				threadId: message.threadId,
-				groupSubject: message.group?.subject,
-				imageUrl: message.imageUrl
-			}
-		},
-		metadata: {
-			type: "message",
-			source: "wechat",
-			provider: "wechat",
-			timestamp: message.timestamp,
-			entityName: message.sender,
-			entityUserName: message.sender,
-			fromId: message.sender,
-			sourceId: stringToUuid(`wechat:entity:${accountId}:${message.sender}`),
-			chatType: getChannelType(message),
-			messageIdFull: message.id,
-			sender: {
-				id: message.sender,
-				name: message.sender,
-				username: message.sender
-			},
-			wechat: {
-				id: message.sender,
-				userId: message.sender,
-				username: message.sender,
-				userName: message.sender,
-				name: message.sender,
-				messageId: message.id,
-				accountId,
-				recipient: message.recipient,
-				threadId: message.threadId,
-				groupSubject: message.group?.subject
-			}
-		}
-	};
-}
-function buildReplyMemory(agentId, accountId, message, text, replyIndex) {
-	return {
-		id: stringToUuid(`wechat:reply:${accountId}:${message.id}:${replyIndex}`),
-		agentId,
-		entityId: agentId,
-		roomId: stringToUuid(`wechat:room:${accountId}:${resolveChannelId(message)}`),
-		createdAt: Date.now(),
-		content: {
-			text,
-			source: "wechat",
-			channelType: getChannelType(message),
-			inReplyTo: message.id,
-			metadata: {
-				accountId,
-				recipient: resolveReplyTarget(message)
-			}
-		},
-		metadata: {
-			type: "message",
-			source: "wechat",
-			provider: "wechat",
-			timestamp: Date.now(),
-			fromBot: true,
-			fromId: agentId,
-			sourceId: agentId,
-			chatType: getChannelType(message),
-			messageIdFull: `wechat:reply:${message.id}:${replyIndex}`,
-			wechat: {
-				accountId,
-				recipient: resolveReplyTarget(message),
-				threadId: message.threadId
-			}
-		}
-	};
-}
-function getChannelType(message) {
-	return message.group ? "GROUP" : "DM";
-}
-function resolveChannelId(message) {
-	return message.threadId ?? message.sender;
-}
-function resolveReplyTarget(message) {
-	return message.threadId ?? message.sender;
-}
-function extractReplyText(content) {
-	if (typeof content.text !== "string") return null;
-	const trimmed = content.text.trim();
-	return trimmed.length > 0 ? trimmed : null;
-}
-async function maybeHandleResponseContent(result, replyDelivered, onResponse) {
-	if (replyDelivered || !result?.responseContent) return;
-	await onResponse(result.responseContent);
-}
-
-//#endregion
-export { deliverIncomingWechatMessage };

package/dist/types.d.ts

@@ -1,61 +0,0 @@
-//#region src/types.d.ts
-type DeviceType = "ipad" | "mac";
-type LoginStatus = "waiting" | "need_verify" | "logged_in";
-interface WechatAccountConfig {
-  enabled?: boolean;
-  name?: string;
-  apiKey: string;
-  proxyUrl: string;
-  deviceType?: DeviceType;
-  webhookPort?: number;
-  webhookUrl?: string;
-  wcId?: string;
-  nickName?: string;
-}
-interface WechatConfig {
-  enabled?: boolean;
-  apiKey?: string;
-  proxyUrl?: string;
-  webhookPort?: number;
-  deviceType?: DeviceType;
-  loginTimeoutMs?: number;
-  accounts?: Record<string, WechatAccountConfig>;
-  features?: {
-    images?: boolean;
-    groups?: boolean;
-  };
-}
-interface ResolvedWechatAccount {
-  id: string;
-  apiKey: string;
-  proxyUrl: string;
-  deviceType: DeviceType;
-  webhookPort: number;
-  wcId?: string;
-  nickName?: string;
-}
-type WechatMessageType = "text" | "image" | "video" | "file" | "voice" | "unknown";
-interface WechatMessageContext {
-  id: string;
-  type: WechatMessageType;
-  sender: string;
-  recipient: string;
-  content: string;
-  timestamp: number;
-  threadId?: string;
-  group?: {
-    subject: string;
-  };
-  imageUrl?: string;
-  raw: unknown;
-}
-interface AccountStatus {
-  valid: boolean;
-  wcId?: string;
-  loginState: LoginStatus;
-  nickName?: string;
-  tier?: string;
-  quota?: number;
-}
-//#endregion
-export { AccountStatus, ResolvedWechatAccount, WechatConfig, WechatMessageContext };

package/dist/utils/qrcode.js

@@ -1,20 +0,0 @@
-//#region src/utils/qrcode.ts
-/**
-* Display a QR code URL to the terminal.
-* Prints the URL for the user to open in a browser.
-* A vendored text-based QR renderer could be added here later.
-*/
-function displayQRUrl(url) {
-	console.log("");
-	console.log("╔══════════════════════════════════════════╗");
-	console.log("║  Scan this QR code with WeChat to login  ║");
-	console.log("╠══════════════════════════════════════════╣");
-	console.log(`║  ${url}`);
-	console.log("╚══════════════════════════════════════════╝");
-	console.log("");
-	console.log("Open the URL above in your browser to see the QR code.");
-	console.log("");
-}
-
-//#endregion
-export { displayQRUrl };

package/src/callback-server.test.ts

@@ -1,190 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { startCallbackServer } from "./callback-server";
-
-const servers: Array<{ close: () => Promise<void> }> = [];
-
-afterEach(async () => {
-  await Promise.all(servers.splice(0).map((server) => server.close()));
-});
-
-describe("startCallbackServer", () => {
-  it("routes a webhook to the matching account and validates that account's API key", async () => {
-    const onMessage = vi.fn();
-    const server = await startCallbackServer({
-      port: 0,
-      accounts: [
-        { accountId: "main", apiKey: "main-key" },
-        { accountId: "secondary", apiKey: "secondary-key" },
-      ],
-      onMessage,
-    });
-    servers.push(server);
-
-    const response = await fetch(
-      `http://127.0.0.1:${server.port}/webhook/wechat/secondary`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-api-key": "secondary-key",
-        },
-        body: JSON.stringify({
-          type: 60001,
-          sender: "wxid-alice",
-          recipient: "wxid-agent",
-          content: "hello",
-          timestamp: 123,
-        }),
-      },
-    );
-
-    expect(response.status).toBe(200);
-    expect(onMessage).toHaveBeenCalledWith(
-      "secondary",
-      expect.objectContaining({
-        sender: "wxid-alice",
-        content: "hello",
-      }),
-    );
-  });
-
-  it("rejects requests signed with another account's API key", async () => {
-    const onMessage = vi.fn();
-    const server = await startCallbackServer({
-      port: 0,
-      accounts: [
-        { accountId: "main", apiKey: "main-key" },
-        { accountId: "secondary", apiKey: "secondary-key" },
-      ],
-      onMessage,
-    });
-    servers.push(server);
-
-    const response = await fetch(
-      `http://127.0.0.1:${server.port}/webhook/wechat/secondary`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-api-key": "main-key",
-        },
-        body: JSON.stringify({
-          type: 60001,
-          sender: "wxid-alice",
-          recipient: "wxid-agent",
-          content: "hello",
-          timestamp: 123,
-        }),
-      },
-    );
-
-    expect(response.status).toBe(401);
-    expect(onMessage).not.toHaveBeenCalled();
-  });
-
-  it("rejects oversized webhook payloads", async () => {
-    const onMessage = vi.fn();
-    const server = await startCallbackServer({
-      port: 0,
-      accounts: [{ accountId: "main", apiKey: "main-key" }],
-      maxBodyBytes: 64,
-      onMessage,
-    });
-    servers.push(server);
-
-    const response = await fetch(
-      `http://127.0.0.1:${server.port}/webhook/wechat/main`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-api-key": "main-key",
-        },
-        body: JSON.stringify({
-          type: 60001,
-          sender: "wxid-alice",
-          recipient: "wxid-agent",
-          content: "x".repeat(512),
-          timestamp: 123,
-        }),
-      },
-    );
-
-    expect(response.status).toBe(413);
-    expect(onMessage).not.toHaveBeenCalled();
-  });
-
-  it("maps voice message type correctly", async () => {
-    const onMessage = vi.fn();
-    const server = await startCallbackServer({
-      port: 0,
-      accounts: [{ accountId: "main", apiKey: "key" }],
-      onMessage,
-    });
-    servers.push(server);
-
-    const response = await fetch(
-      `http://127.0.0.1:${server.port}/webhook/wechat/main`,
-      {
-        method: "POST",
-        headers: { "content-type": "application/json", "x-api-key": "key" },
-        body: JSON.stringify({
-          data: {
-            type: 60003,
-            sender: "wxid-alice",
-            recipient: "wxid-agent",
-            content: "",
-            timestamp: 456,
-            mediaUrl: "https://example.com/voice.amr",
-          },
-        }),
-      },
-    );
-
-    expect(response.status).toBe(200);
-    expect(onMessage).toHaveBeenCalledWith(
-      "main",
-      expect.objectContaining({
-        type: "voice",
-        imageUrl: "https://example.com/voice.amr",
-      }),
-    );
-  });
-
-  it("maps group video message type correctly", async () => {
-    const onMessage = vi.fn();
-    const server = await startCallbackServer({
-      port: 0,
-      accounts: [{ accountId: "main", apiKey: "key" }],
-      onMessage,
-    });
-    servers.push(server);
-
-    const response = await fetch(
-      `http://127.0.0.1:${server.port}/webhook/wechat/main`,
-      {
-        method: "POST",
-        headers: { "content-type": "application/json", "x-api-key": "key" },
-        body: JSON.stringify({
-          data: {
-            type: 80004,
-            sender: "room@chatroom",
-            recipient: "wxid-agent",
-            content: "",
-            timestamp: 789,
-            mediaUrl: "https://example.com/video.mp4",
-          },
-        }),
-      },
-    );
-
-    expect(response.status).toBe(200);
-    expect(onMessage).toHaveBeenCalledWith(
-      "main",
-      expect.objectContaining({
-        type: "video",
-        imageUrl: "https://example.com/video.mp4",
-      }),
-    );
-  });
-});

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");
-  });
-});