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

package/dist/proxy-client.d.ts

@@ -1,35 +0,0 @@
-import { AccountStatus, ResolvedWechatAccount } from "./types.js";
-
-//#region src/proxy-client.d.ts
-declare class ProxyClient {
-  private readonly apiKey;
-  private readonly baseUrl;
-  private readonly accountId;
-  private readonly deviceType;
-  constructor(account: ResolvedWechatAccount);
-  private request;
-  getStatus(): Promise<AccountStatus>;
-  getQRCode(): Promise<string>;
-  checkLogin(): Promise<{
-    status: "waiting" | "need_verify" | "logged_in";
-    verifyUrl?: string;
-    wcId?: string;
-    nickName?: string;
-  }>;
-  sendText(to: string, text: string): Promise<void>;
-  sendImage(to: string, imagePath: string, text?: string): Promise<void>;
-  getContacts(): Promise<{
-    friends: Array<{
-      wxid: string;
-      name: string;
-    }>;
-    chatrooms: Array<{
-      wxid: string;
-      name: string;
-    }>;
-  }>;
-  registerWebhook(url: string): Promise<void>;
-  get needsLogin(): boolean;
-}
-//#endregion
-export { ProxyClient };

package/dist/proxy-client.js

@@ -1,117 +0,0 @@
-//#region src/proxy-client.ts
-const SUCCESS = 1e3;
-const LOGIN_NEEDED = 1001;
-const REQUEST_TIMEOUT_MS = 3e4;
-var ProxyClient = class {
-	apiKey;
-	baseUrl;
-	accountId;
-	deviceType;
-	constructor(account) {
-		this.apiKey = account.apiKey;
-		this.baseUrl = normalizeProxyUrl(account.proxyUrl);
-		this.accountId = account.id;
-		this.deviceType = account.deviceType ?? "ipad";
-	}
-	async request(path, body) {
-		const url = `${this.baseUrl}${path}`;
-		const headers = {
-			"Content-Type": "application/json",
-			"X-API-Key": this.apiKey,
-			"X-Account-ID": this.accountId,
-			"X-Device-Type": this.deviceType
-		};
-		let lastError;
-		for (let attempt = 0; attempt < 3; attempt++) try {
-			const res = await fetch(url, {
-				method: "POST",
-				headers,
-				body: body ? JSON.stringify(body) : void 0,
-				signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-			});
-			if (res.status === 429) {
-				const retryAfter = res.headers.get("Retry-After");
-				const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : Math.min(1e3 * 2 ** attempt, 8e3);
-				await res.text().catch(() => {});
-				await sleep(delay);
-				continue;
-			}
-			return await res.json();
-		} catch (err) {
-			lastError = err instanceof Error ? err : new Error(String(err));
-			await sleep(Math.min(1e3 * 2 ** attempt, 8e3));
-		}
-		throw lastError ?? /* @__PURE__ */ new Error(`Request failed after 3 attempts: ${path}`);
-	}
-	async getStatus() {
-		const res = await this.request("/api/status");
-		if (res.code === LOGIN_NEEDED) return {
-			valid: true,
-			loginState: "waiting"
-		};
-		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`getStatus failed: ${res.message ?? res.code}`);
-		return requireData(res, "getStatus");
-	}
-	async getQRCode() {
-		const res = await this.request("/api/qrcode");
-		if (res.code !== SUCCESS) throw new Error(`getQRCode failed: ${res.message ?? res.code}`);
-		return requireData(res, "getQRCode").qrCodeUrl;
-	}
-	async checkLogin() {
-		const res = await this.request("/api/check-login");
-		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`checkLogin failed: ${res.message ?? res.code}`);
-		return requireData(res, "checkLogin");
-	}
-	async sendText(to, text) {
-		const res = await this.request("/api/send-text", {
-			to,
-			text
-		});
-		if (res.code === LOGIN_NEEDED) throw new LoginExpiredError();
-		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`sendText failed: ${res.message ?? res.code}`);
-	}
-	async sendImage(to, imagePath, text) {
-		const res = await this.request("/api/send-image", {
-			to,
-			imagePath,
-			text
-		});
-		if (res.code === LOGIN_NEEDED) throw new LoginExpiredError();
-		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`sendImage failed: ${res.message ?? res.code}`);
-	}
-	async getContacts() {
-		const res = await this.request("/api/contacts");
-		if (res.code !== SUCCESS) throw new Error(`getContacts failed: ${res.message ?? res.code}`);
-		return requireData(res, "getContacts");
-	}
-	async registerWebhook(url) {
-		const res = await this.request("/api/webhook/register", { webhookUrl: url });
-		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`registerWebhook failed: ${res.message ?? res.code}`);
-	}
-	get needsLogin() {
-		return false;
-	}
-};
-var LoginExpiredError = class extends Error {
-	constructor() {
-		super("WeChat login expired — re-login required");
-		this.name = "LoginExpiredError";
-	}
-};
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function normalizeProxyUrl(proxyUrl) {
-	const parsed = new URL(proxyUrl);
-	if (parsed.protocol !== "https:") throw new Error("[wechat] proxyUrl must use https://");
-	if (parsed.username || parsed.password) throw new Error("[wechat] proxyUrl must not include credentials");
-	parsed.hash = "";
-	return parsed.toString().replace(/\/$/, "");
-}
-function requireData(response, action) {
-	if (response.data === void 0) throw new Error(`${action} failed: missing response data`);
-	return response.data;
-}
-
-//#endregion
-export { LoginExpiredError, ProxyClient };

package/dist/reply-dispatcher.d.ts

@@ -1,17 +0,0 @@
-import { ProxyClient } from "./proxy-client.js";
-
-//#region src/reply-dispatcher.d.ts
-interface ReplyDispatcherOptions {
-  client: ProxyClient;
-  chunkSize?: number;
-}
-declare class ReplyDispatcher {
-  private readonly client;
-  private readonly chunkSize;
-  constructor(options: ReplyDispatcherOptions);
-  sendText(to: string, text: string): Promise<void>;
-  sendImage(to: string, imagePath: string, caption?: string): Promise<void>;
-  private chunk;
-}
-//#endregion
-export { ReplyDispatcher };

package/dist/reply-dispatcher.js

@@ -1,47 +0,0 @@
-//#region src/reply-dispatcher.ts
-const DEFAULT_CHUNK_SIZE = 2e3;
-var ReplyDispatcher = class {
-	client;
-	chunkSize;
-	constructor(options) {
-		this.client = options.client;
-		this.chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
-	}
-	async sendText(to, text) {
-		const chunks = this.chunk(text);
-		for (const chunk of chunks) try {
-			await this.client.sendText(to, chunk);
-		} catch (err) {
-			console.error(`[wechat] Failed to send text to ${to}:`, err);
-			throw err;
-		}
-	}
-	async sendImage(to, imagePath, caption) {
-		try {
-			await this.client.sendImage(to, imagePath, caption);
-		} catch (err) {
-			console.error(`[wechat] Failed to send image to ${to}:`, err);
-			throw err;
-		}
-	}
-	chunk(text) {
-		if (text.length <= this.chunkSize) return [text];
-		const chunks = [];
-		let remaining = text;
-		while (remaining.length > 0) {
-			if (remaining.length <= this.chunkSize) {
-				chunks.push(remaining);
-				break;
-			}
-			let breakAt = remaining.lastIndexOf("\n", this.chunkSize);
-			if (breakAt <= 0) breakAt = remaining.lastIndexOf(" ", this.chunkSize);
-			if (breakAt <= 0) breakAt = this.chunkSize;
-			chunks.push(remaining.slice(0, breakAt));
-			remaining = remaining.slice(breakAt).trimStart();
-		}
-		return chunks;
-	}
-};
-
-//#endregion
-export { ReplyDispatcher };

package/dist/runtime-bridge.d.ts

@@ -1,12 +0,0 @@
-import { WechatMessageContext } from "./types.js";
-
-//#region src/runtime-bridge.d.ts
-interface IncomingWechatDeliveryOptions {
-  runtime: unknown;
-  accountId: string;
-  message: WechatMessageContext;
-  sendText: (accountId: string, to: string, text: string) => Promise<void>;
-}
-declare function deliverIncomingWechatMessage(options: IncomingWechatDeliveryOptions): Promise<void>;
-//#endregion
-export { deliverIncomingWechatMessage };

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