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

package/src/index.ts

@@ -1,4 +1,15 @@
+import {
+  type Content,
+  getConnectorAccountManager,
+  type IAgentRuntime,
+  type Memory,
+  type MessageConnectorTarget,
+  stringToUuid,
+  type TargetInfo,
+  type UUID,
+} from "@elizaos/core";
 import { WechatChannel } from "./channel";
+import { createWechatConnectorAccountProvider } from "./connector-account-provider";
 import { deliverIncomingWechatMessage } from "./runtime-bridge";
 import type { WechatConfig, WechatMessageContext } from "./types";
 
@@ -37,17 +48,337 @@ export interface Plugin {
     config: Record<string, unknown>,
     runtime: unknown,
   ) => Promise<void | (() => Promise<void>)>;
+  dispose?: () => Promise<void> | void;
+  /**
+   * Declarative auto-enable conditions consumed by the runtime's
+   * plugin-auto-enable engine. Mirrors the shape on `@elizaos/core` Plugin.
+   */
+  autoEnable?: {
+    envKeys?: string[];
+    connectorKeys?: string[];
+    shouldEnable?: (
+      env: Record<string, string | undefined>,
+      config: Record<string, unknown>,
+    ) => boolean;
+  };
 }
 
 let channel: WechatChannel | null = null;
 
+type RuntimeWithWechatConnector = {
+  registerMessageConnector?: (registration: Record<string, unknown>) => void;
+  getMessageConnectors?: () => Array<{
+    source?: string;
+    fetchMessages?: (
+      context: { runtime: IAgentRuntime; target?: TargetInfo },
+      params?: WechatConnectorReadParams,
+    ) => Promise<Memory[]>;
+  }>;
+  registerSendHandler?: (
+    source: string,
+    handler: (
+      runtime: IAgentRuntime,
+      target: TargetInfo,
+      content: Content,
+    ) => Promise<void>,
+  ) => void;
+};
+
+type WechatConnectorReadParams = {
+  target?: TargetInfo;
+  limit?: number;
+  query?: string;
+};
+
+function readRuntimeSetting(runtime: unknown, key: string): string | undefined {
+  const value = (
+    runtime as { getSetting?: (setting: string) => unknown }
+  ).getSetting?.(key);
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function resolveWechatConfig(
+  config: Record<string, unknown>,
+  runtime: unknown,
+): WechatConfig | undefined {
+  const explicit = (config as { connectors?: { wechat?: WechatConfig } })
+    ?.connectors?.wechat;
+  if (explicit) return explicit;
+  const apiKey = readRuntimeSetting(runtime, "WECHAT_API_KEY");
+  const proxyUrl = readRuntimeSetting(runtime, "WECHAT_PROXY_URL");
+  if (!apiKey && !proxyUrl) return undefined;
+  return {
+    apiKey,
+    proxyUrl,
+  };
+}
+
+function normalizeConnectorLimit(
+  limit: number | undefined,
+  fallback = 50,
+): number {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(limit), 200);
+}
+
+function getConfiguredAccountIds(config: WechatConfig): string[] {
+  if (config.accounts && typeof config.accounts === "object") {
+    return Object.entries(config.accounts)
+      .filter(
+        ([, account]) => account.enabled !== false && Boolean(account.apiKey),
+      )
+      .map(([id]) => id);
+  }
+  return config.apiKey ? ["default"] : [];
+}
+
+function resolveWechatAccountId(
+  config: WechatConfig,
+  target?: TargetInfo,
+): string {
+  const metadata = (
+    target as (TargetInfo & { metadata?: Record<string, unknown> }) | undefined
+  )?.metadata;
+  const accountId =
+    typeof metadata?.accountId === "string" && metadata.accountId.trim()
+      ? metadata.accountId.trim()
+      : undefined;
+  if (accountId) {
+    return accountId;
+  }
+  return (
+    channel?.getAccountIds()[0] ??
+    getConfiguredAccountIds(config)[0] ??
+    "default"
+  );
+}
+
+function wechatTarget(
+  accountId: string,
+  wxid: string,
+  name: string | undefined,
+  kind: "user" | "group",
+  score = 0.55,
+): MessageConnectorTarget {
+  return {
+    target: {
+      source: "wechat",
+      channelId: wxid,
+      roomId: stringToUuid(`wechat:room:${accountId}:${wxid}`) as UUID,
+      metadata: { accountId },
+    } as TargetInfo,
+    label: name || wxid,
+    kind,
+    score,
+    contexts: ["social", "connectors"],
+    metadata: { accountId, wxid },
+  };
+}
+
+async function listWechatTargets(
+  config: WechatConfig,
+): Promise<MessageConnectorTarget[]> {
+  if (!channel) {
+    return [];
+  }
+  const targets: MessageConnectorTarget[] = [];
+  for (const accountId of channel.getAccountIds()) {
+    const contacts = await channel.listContacts(accountId).catch(() => null);
+    if (!contacts) {
+      continue;
+    }
+    targets.push(
+      ...contacts.friends.map((friend) =>
+        wechatTarget(accountId, friend.wxid, friend.name, "user"),
+      ),
+      ...contacts.chatrooms.map((chatroom) =>
+        wechatTarget(accountId, chatroom.wxid, chatroom.name, "group"),
+      ),
+    );
+  }
+  if (targets.length > 0) {
+    return targets;
+  }
+  return getConfiguredAccountIds(config).map((accountId) =>
+    wechatTarget(
+      accountId,
+      accountId,
+      `WeChat account ${accountId}`,
+      "user",
+      0.25,
+    ),
+  );
+}
+
+function filterMemoriesByQuery(
+  memories: Memory[],
+  query: string,
+  limit: number,
+): Memory[] {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return memories.slice(0, limit);
+  }
+  return memories
+    .filter((memory) => {
+      const text =
+        typeof memory.content?.text === "string" ? memory.content.text : "";
+      return text.toLowerCase().includes(normalized);
+    })
+    .slice(0, limit);
+}
+
+function registerWechatMessageConnector(
+  runtime: unknown,
+  config: WechatConfig,
+): void {
+  const connectorRuntime = runtime as RuntimeWithWechatConnector;
+  const sendHandler = async (
+    _runtime: IAgentRuntime,
+    target: TargetInfo,
+    content: Content,
+  ): Promise<void> => {
+    if (!channel) {
+      throw new Error("[wechat] Channel is not available");
+    }
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    if (!text) {
+      return;
+    }
+    const accountId = resolveWechatAccountId(config, target);
+    const to = String(target.channelId ?? target.entityId ?? "").trim();
+    if (!to) {
+      throw new Error("[wechat] target is missing channelId/entityId");
+    }
+    await channel.sendText(accountId, to, text);
+  };
+
+  if (typeof connectorRuntime.registerMessageConnector === "function") {
+    connectorRuntime.registerMessageConnector({
+      source: "wechat",
+      label: "WeChat",
+      description:
+        "WeChat connector for sending and reading stored DM/group messages.",
+      capabilities: [
+        "send_message",
+        "resolve_targets",
+        "list_rooms",
+        "chat_context",
+      ],
+      supportedTargetKinds: ["user", "group", "room"],
+      contexts: ["social", "connectors"],
+      resolveTargets: async (query: string) => {
+        const normalized = query.trim().toLowerCase();
+        return (await listWechatTargets(config))
+          .map((target) => {
+            const haystack =
+              `${target.label ?? ""} ${target.target.channelId ?? ""}`.toLowerCase();
+            return {
+              ...target,
+              score:
+                normalized && haystack.includes(normalized)
+                  ? 0.8
+                  : (target.score ?? 0.4),
+            };
+          })
+          .filter((target) => !normalized || (target.score ?? 0) >= 0.8)
+          .slice(0, 25);
+      },
+      listRecentTargets: async () =>
+        (await listWechatTargets(config)).slice(0, 10),
+      listRooms: async () => listWechatTargets(config),
+      fetchMessages: async (
+        context: { runtime: IAgentRuntime; target?: TargetInfo },
+        params?: WechatConnectorReadParams,
+      ) => {
+        const limit = normalizeConnectorLimit(params?.limit);
+        const target = params?.target ?? context.target;
+        if (target?.roomId) {
+          return context.runtime.getMemories({
+            tableName: "messages",
+            roomId: target.roomId,
+            limit,
+            orderBy: "createdAt",
+            orderDirection: "desc",
+          });
+        }
+        const targets = (await listWechatTargets(config)).slice(0, 10);
+        const chunks = await Promise.all(
+          targets
+            .map((candidate) => candidate.target.roomId)
+            .filter((roomId): roomId is UUID => Boolean(roomId))
+            .map((roomId) =>
+              context.runtime.getMemories({
+                tableName: "messages",
+                roomId,
+                limit,
+                orderBy: "createdAt",
+                orderDirection: "desc",
+              }),
+            ),
+        );
+        return chunks
+          .flat()
+          .sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0))
+          .slice(0, limit);
+      },
+      searchMessages: async (
+        context: { runtime: IAgentRuntime; target?: TargetInfo },
+        params: WechatConnectorReadParams & { query: string },
+      ) => {
+        const limit = normalizeConnectorLimit(params.limit);
+        const registration = connectorRuntime
+          .getMessageConnectors?.()
+          .find((connector) => connector.source === "wechat") as
+          | {
+              fetchMessages?: (
+                context: { runtime: IAgentRuntime; target?: TargetInfo },
+                params?: WechatConnectorReadParams,
+              ) => Promise<Memory[]>;
+            }
+          | undefined;
+        const messages =
+          (await registration?.fetchMessages?.(context, {
+            target: params.target ?? context.target,
+            limit: Math.max(limit, 100),
+          })) ?? [];
+        return filterMemoriesByQuery(messages, params.query, limit);
+      },
+      sendHandler,
+    });
+    return;
+  }
+
+  connectorRuntime.registerSendHandler?.("wechat", sendHandler);
+}
+
 const wechatPlugin: Plugin = {
   name: "wechat",
   description: "WeChat messaging via proxy API",
 
+  // Self-declared auto-enable: activate when the "wechat" connector is
+  // configured under config.connectors. The hardcoded CONNECTOR_PLUGINS map
+  // in plugin-auto-enable-engine.ts still serves as a fallback.
+  autoEnable: {
+    connectorKeys: ["wechat"],
+  },
+
   async init(config: Record<string, unknown>, runtime: unknown) {
-    const wechatConfig = (config as { connectors?: { wechat?: WechatConfig } })
-      ?.connectors?.wechat;
+    try {
+      const manager = getConnectorAccountManager(runtime as IAgentRuntime);
+      manager.registerProvider(
+        createWechatConnectorAccountProvider(runtime as IAgentRuntime),
+      );
+    } catch (err) {
+      console.warn(
+        "[wechat] Failed to register provider with ConnectorAccountManager:",
+        err instanceof Error ? err.message : String(err),
+      );
+    }
+
+    const wechatConfig = resolveWechatConfig(config, runtime);
 
     if (!wechatConfig) {
       console.warn("[wechat] No wechat config found in connectors — skipping");
@@ -77,6 +408,7 @@ const wechatPlugin: Plugin = {
     });
 
     await channel.start();
+    registerWechatMessageConnector(runtime, wechatConfig);
     console.log("[wechat] Plugin initialized");
 
     // Return cleanup function
@@ -88,6 +420,13 @@ const wechatPlugin: Plugin = {
       }
     };
   },
+  async dispose() {
+    if (channel) {
+      await channel.stop();
+      channel = null;
+      console.log("[wechat] Plugin disposed");
+    }
+  },
 };
 
 export default wechatPlugin;

package/src/types.ts

@@ -1,7 +1,7 @@
-export type DeviceType = "ipad" | "mac";
-export type LoginStatus = "waiting" | "need_verify" | "logged_in";
+type DeviceType = "ipad" | "mac";
+type LoginStatus = "waiting" | "need_verify" | "logged_in";
 
-export interface WechatAccountConfig {
+interface WechatAccountConfig {
   enabled?: boolean;
   name?: string;
   apiKey: string;

package/dist/bot.d.ts

@@ -1,25 +0,0 @@
-import { WechatMessageContext } from "./types.js";
-
-//#region src/bot.d.ts
-interface BotOptions {
-  onMessage: (msg: WechatMessageContext) => void | Promise<void>;
-  featuresGroups?: boolean;
-  featuresImages?: boolean;
-  /** Deduplication window in milliseconds. Defaults to 30 minutes. */
-  dedupWindowMs?: number;
-}
-declare class Bot {
-  private readonly seen;
-  private readonly onMessage;
-  private readonly featuresGroups;
-  private readonly featuresImages;
-  private readonly dedupWindowMs;
-  private cleanupTimer;
-  constructor(options: BotOptions);
-  handleIncoming(message: WechatMessageContext): void;
-  private isDuplicate;
-  private cleanup;
-  stop(): void;
-}
-//#endregion
-export { Bot };

package/dist/bot.js

@@ -1,49 +0,0 @@
-//#region src/bot.ts
-const DEFAULT_DEDUP_WINDOW_MS = 1800 * 1e3;
-const DEDUP_MAX_ENTRIES = 1e3;
-const DEDUP_CLEANUP_INTERVAL_MS = 300 * 1e3;
-var Bot = class {
-	seen = /* @__PURE__ */ new Map();
-	onMessage;
-	featuresGroups;
-	featuresImages;
-	dedupWindowMs;
-	cleanupTimer = null;
-	constructor(options) {
-		this.onMessage = options.onMessage;
-		this.featuresGroups = options.featuresGroups ?? true;
-		this.featuresImages = options.featuresImages ?? true;
-		this.dedupWindowMs = options.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
-		this.cleanupTimer = setInterval(() => this.cleanup(), DEDUP_CLEANUP_INTERVAL_MS);
-	}
-	handleIncoming(message) {
-		if (this.isDuplicate(message.id)) return;
-		if (message.group && !this.featuresGroups) return;
-		if (message.type === "image" && !this.featuresImages) return;
-		if (message.type === "unknown") return;
-		Promise.resolve(this.onMessage(message)).catch((error) => {
-			console.error("[wechat] Failed to process inbound message:", error);
-		});
-	}
-	isDuplicate(messageId) {
-		const now = Date.now();
-		if (this.seen.has(messageId)) return true;
-		if (this.seen.size >= DEDUP_MAX_ENTRIES) this.cleanup();
-		this.seen.set(messageId, now);
-		return false;
-	}
-	cleanup() {
-		const cutoff = Date.now() - this.dedupWindowMs;
-		for (const [id, ts] of this.seen) if (ts < cutoff) this.seen.delete(id);
-	}
-	stop() {
-		if (this.cleanupTimer) {
-			clearInterval(this.cleanupTimer);
-			this.cleanupTimer = null;
-		}
-		this.seen.clear();
-	}
-};
-
-//#endregion
-export { Bot };

package/dist/callback-server.js

@@ -1,207 +0,0 @@
-import { timingSafeEqual } from "node:crypto";
-import { createServer } from "node:http";
-
-//#region src/callback-server.ts
-const WECHAT_TYPE_MAP = {
-	60001: {
-		type: "text",
-		scope: "private"
-	},
-	60002: {
-		type: "image",
-		scope: "private"
-	},
-	60003: {
-		type: "voice",
-		scope: "private"
-	},
-	60004: {
-		type: "video",
-		scope: "private"
-	},
-	60005: {
-		type: "file",
-		scope: "private"
-	},
-	80001: {
-		type: "text",
-		scope: "group"
-	},
-	80002: {
-		type: "image",
-		scope: "group"
-	},
-	80003: {
-		type: "voice",
-		scope: "group"
-	},
-	80004: {
-		type: "video",
-		scope: "group"
-	},
-	80005: {
-		type: "file",
-		scope: "group"
-	}
-};
-const DEFAULT_MAX_REQUEST_BODY_BYTES = 1024 * 1024;
-async function startCallbackServer(options) {
-	const { port, accounts, onMessage, signal, maxBodyBytes = DEFAULT_MAX_REQUEST_BODY_BYTES } = options;
-	const server = createServer((req, res) => {
-		const account = resolveWebhookAccount(req.url, accounts);
-		if (req.method !== "POST" || !account) {
-			res.writeHead(404);
-			res.end("Not Found");
-			return;
-		}
-		const incomingKey = readHeaderValue(req.headers["x-api-key"]);
-		if (!incomingKey || !safeCompare(incomingKey, account.apiKey)) {
-			res.writeHead(401);
-			res.end("Unauthorized");
-			return;
-		}
-		let body = "";
-		let bodyBytes = 0;
-		req.on("data", (chunk) => {
-			bodyBytes += chunk.length;
-			if (bodyBytes > maxBodyBytes) {
-				res.writeHead(413);
-				res.end("Payload Too Large");
-				req.destroy();
-				return;
-			}
-			body += chunk.toString();
-		});
-		req.on("end", () => {
-			if (res.writableEnded) return;
-			try {
-				const message = normalizePayload(JSON.parse(body));
-				if (message) onMessage(account.accountId, message);
-				res.writeHead(200);
-				res.end("OK");
-			} catch {
-				res.writeHead(400);
-				res.end("Bad Request");
-			}
-		});
-		req.on("error", () => {
-			if (res.writableEnded) return;
-			res.writeHead(400);
-			res.end("Bad Request");
-		});
-	});
-	await new Promise((resolve, reject) => {
-		const handleListening = () => {
-			server.off("error", handleError);
-			resolve();
-		};
-		const handleError = (error) => {
-			server.off("listening", handleListening);
-			reject(error);
-		};
-		server.once("listening", handleListening);
-		server.once("error", handleError);
-		server.listen(port);
-	});
-	const listeningPort = server.address()?.port ?? port;
-	console.log(`[wechat] Webhook server listening on port ${listeningPort}`);
-	server.on("error", (err) => {
-		if (err.code === "EADDRINUSE") console.error(`[wechat] Port ${listeningPort} already in use — webhook server failed to start`);
-		else console.error(`[wechat] Webhook server error:`, err);
-	});
-	if (signal) signal.addEventListener("abort", () => {
-		closeServer(server);
-	}, { once: true });
-	return {
-		close: () => closeServer(server),
-		port: listeningPort
-	};
-}
-function resolveWebhookAccount(rawUrl, accounts) {
-	if (!rawUrl) return null;
-	const pathname = new URL(rawUrl, "http://localhost").pathname;
-	if (pathname === "/webhook/wechat" && accounts.length === 1) return accounts[0];
-	const match = /^\/webhook\/wechat\/([^/]+)$/.exec(pathname);
-	if (!match) return null;
-	const accountId = decodeURIComponent(match[1]);
-	return accounts.find((account) => account.accountId === accountId) ?? null;
-}
-function readHeaderValue(value) {
-	if (Array.isArray(value)) return value[0];
-	return value;
-}
-function safeCompare(a, b) {
-	const bufA = Buffer.from(a);
-	const bufB = Buffer.from(b);
-	if (bufA.length !== bufB.length) {
-		timingSafeEqual(bufA, bufA);
-		return false;
-	}
-	return timingSafeEqual(bufA, bufB);
-}
-function closeServer(server) {
-	if (!server.listening) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		server.close((error) => {
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve();
-		});
-	});
-}
-function normalizePayload(payload) {
-	const data = payload.data ?? (payload.content ? payload : null);
-	if (!data) {
-		console.warn("[wechat] Unrecognized webhook payload format");
-		return null;
-	}
-	const typeCode = Number(data.type ?? data.msgType ?? 0);
-	const mapping = WECHAT_TYPE_MAP[typeCode];
-	let msgType = "unknown";
-	let scope = "private";
-	if (mapping) {
-		msgType = mapping.type;
-		scope = mapping.scope;
-	} else if (typeCode >= 60006 && typeCode <= 60010) {
-		msgType = "file";
-		scope = "private";
-	} else if (typeCode >= 80006 && typeCode <= 80010) {
-		msgType = "file";
-		scope = "group";
-	}
-	if (msgType === "unknown") {
-		console.warn(`[wechat] Unknown message type code: ${typeCode}`);
-		return null;
-	}
-	const sender = String(data.sender ?? data.from ?? "");
-	const recipient = String(data.recipient ?? data.to ?? "");
-	const content = String(data.content ?? data.text ?? "");
-	const timestamp = Number(data.timestamp ?? Date.now());
-	const msgId = String(data.msgId ?? data.id ?? `${sender}-${timestamp}`);
-	const isGroup = scope === "group" || sender.includes("@chatroom");
-	const threadId = isGroup ? String(data.roomId ?? data.threadId ?? sender) : void 0;
-	const groupSubject = isGroup ? String(data.roomName ?? data.groupName ?? threadId ?? "") : void 0;
-	const imageUrl = new Set([
-		"image",
-		"voice",
-		"video",
-		"file"
-	]).has(msgType) ? String(data.imageUrl ?? data.mediaUrl ?? data.url ?? data.fileUrl ?? "") : void 0;
-	return {
-		id: msgId,
-		type: msgType,
-		sender,
-		recipient,
-		content,
-		timestamp,
-		threadId,
-		group: groupSubject ? { subject: groupSubject } : void 0,
-		imageUrl: imageUrl || void 0,
-		raw: payload
-	};
-}
-
-//#endregion
-export { startCallbackServer };

package/dist/channel.d.ts

@@ -1,28 +0,0 @@
-import { WechatConfig, WechatMessageContext } from "./types.js";
-
-//#region src/channel.d.ts
-interface ChannelOptions {
-  config: WechatConfig;
-  onMessage: (accountId: string, msg: WechatMessageContext) => void | Promise<void>;
-}
-declare class WechatChannel {
-  private readonly config;
-  private readonly onMessage;
-  private readonly accounts;
-  private readonly callbackServers;
-  private readonly loginPromises;
-  private healthTimer;
-  private abortController;
-  constructor(options: ChannelOptions);
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  sendText(accountId: string, to: string, text: string): Promise<void>;
-  sendImage(accountId: string, to: string, imagePath: string, caption?: string): Promise<void>;
-  private routeIncoming;
-  private ensureLoggedIn;
-  private doLogin;
-  private healthCheck;
-  private resolveAccounts;
-}
-//#endregion
-export { WechatChannel };