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

package/dist/channel.js

@@ -1,194 +0,0 @@
-import { Bot } from "./bot.js";
-import { startCallbackServer } from "./callback-server.js";
-import { LoginExpiredError, ProxyClient } from "./proxy-client.js";
-import { ReplyDispatcher } from "./reply-dispatcher.js";
-import { displayQRUrl } from "./utils/qrcode.js";
-
-//#region src/channel.ts
-const HEALTH_CHECK_INTERVAL_MS = 6e4;
-const LOGIN_POLL_INTERVAL_MS = 5e3;
-const LOGIN_TIMEOUT_MS = 5 * 6e4;
-var WechatChannel = class {
-	config;
-	onMessage;
-	accounts = /* @__PURE__ */ new Map();
-	callbackServers = [];
-	loginPromises = /* @__PURE__ */ new Map();
-	healthTimer = null;
-	abortController = null;
-	constructor(options) {
-		this.config = options.config;
-		this.onMessage = options.onMessage;
-	}
-	async start() {
-		this.abortController = new AbortController();
-		const resolved = this.resolveAccounts();
-		if (resolved.length === 0) {
-			console.warn("[wechat] No configured accounts found");
-			return;
-		}
-		const webhookAccountsByPort = /* @__PURE__ */ new Map();
-		for (const account of resolved) {
-			const existing = webhookAccountsByPort.get(account.webhookPort) ?? [];
-			existing.push({
-				accountId: account.id,
-				apiKey: account.apiKey
-			});
-			webhookAccountsByPort.set(account.webhookPort, existing);
-		}
-		for (const [webhookPort, accounts] of webhookAccountsByPort) try {
-			this.callbackServers.push(await startCallbackServer({
-				port: webhookPort,
-				accounts,
-				onMessage: (accountId, msg) => this.routeIncoming(accountId, msg),
-				signal: this.abortController.signal
-			}));
-		} catch (err) {
-			const accountIds = accounts.map((a) => a.accountId).join(", ");
-			console.error(`[wechat] Failed to bind webhook server on port ${webhookPort} for accounts [${accountIds}]:`, err);
-		}
-		for (const account of resolved) {
-			const client = new ProxyClient(account);
-			const dispatcher = new ReplyDispatcher({ client });
-			const bot = new Bot({
-				onMessage: (msg) => this.onMessage(account.id, msg),
-				featuresGroups: this.config.features?.groups,
-				featuresImages: this.config.features?.images
-			});
-			this.accounts.set(account.id, {
-				client,
-				dispatcher,
-				bot
-			});
-			await this.ensureLoggedIn(account.id, client);
-			const webhookUrl = `http://localhost:${account.webhookPort}/webhook/wechat/${account.id}`;
-			try {
-				await client.registerWebhook(webhookUrl);
-				console.log(`[wechat] Account "${account.id}" registered webhook at ${webhookUrl}`);
-			} catch (err) {
-				console.error(`[wechat] Failed to register webhook for "${account.id}":`, err);
-				throw new Error(`Webhook registration failed for account "${account.id}": ${err instanceof Error ? err.message : String(err)}`);
-			}
-		}
-		this.healthTimer = setInterval(() => this.healthCheck(), HEALTH_CHECK_INTERVAL_MS);
-	}
-	async stop() {
-		if (this.healthTimer) {
-			clearInterval(this.healthTimer);
-			this.healthTimer = null;
-		}
-		for (const [, { bot }] of this.accounts) bot.stop();
-		this.accounts.clear();
-		if (this.abortController) {
-			this.abortController.abort();
-			this.abortController = null;
-		}
-		const servers = this.callbackServers.splice(0);
-		await Promise.all(servers.map((server) => server.close().catch(() => void 0)));
-	}
-	async sendText(accountId, to, text) {
-		const entry = this.accounts.get(accountId);
-		if (!entry) throw new Error(`Unknown account: ${accountId}`);
-		try {
-			await entry.dispatcher.sendText(to, text);
-		} catch (err) {
-			if (err instanceof LoginExpiredError) {
-				await this.ensureLoggedIn(accountId, entry.client);
-				await entry.dispatcher.sendText(to, text);
-			} else throw err;
-		}
-	}
-	async sendImage(accountId, to, imagePath, caption) {
-		const entry = this.accounts.get(accountId);
-		if (!entry) throw new Error(`Unknown account: ${accountId}`);
-		try {
-			await entry.dispatcher.sendImage(to, imagePath, caption);
-		} catch (err) {
-			if (err instanceof LoginExpiredError) {
-				await this.ensureLoggedIn(accountId, entry.client);
-				await entry.dispatcher.sendImage(to, imagePath, caption);
-			} else throw err;
-		}
-	}
-	routeIncoming(accountId, msg) {
-		const entry = this.accounts.get(accountId);
-		if (!entry) {
-			console.warn(`[wechat] Received webhook for unknown account "${accountId}"`);
-			return;
-		}
-		entry.bot.handleIncoming(msg);
-	}
-	async ensureLoggedIn(accountId, client) {
-		const existing = this.loginPromises.get(accountId);
-		if (existing) return existing;
-		const promise = this.doLogin(accountId, client).finally(() => {
-			this.loginPromises.delete(accountId);
-		});
-		this.loginPromises.set(accountId, promise);
-		return promise;
-	}
-	async doLogin(accountId, client) {
-		const status = await client.getStatus();
-		if (status.loginState === "logged_in") {
-			console.log(`[wechat] Account "${accountId}" logged in as ${status.nickName ?? status.wcId}`);
-			return;
-		}
-		console.log(`[wechat] Account "${accountId}" needs login — generating QR code...`);
-		displayQRUrl(await client.getQRCode());
-		const timeoutMs = this.config.loginTimeoutMs ?? LOGIN_TIMEOUT_MS;
-		const deadline = Date.now() + timeoutMs;
-		while (Date.now() < deadline) {
-			await sleep(LOGIN_POLL_INTERVAL_MS);
-			if (this.abortController?.signal.aborted) throw new Error("Login aborted");
-			const result = await client.checkLogin();
-			if (result.status === "logged_in") {
-				console.log(`[wechat] Account "${accountId}" logged in as ${result.nickName ?? result.wcId}`);
-				return;
-			}
-			if (result.status === "need_verify") console.log(`[wechat] Verification needed: ${result.verifyUrl ?? "check your phone"}`);
-		}
-		throw new Error(`[wechat] Login timed out for account "${accountId}" after ${Math.round(timeoutMs / 1e3)} seconds`);
-	}
-	async healthCheck() {
-		for (const [accountId, { client }] of this.accounts) try {
-			if ((await client.getStatus()).loginState !== "logged_in") {
-				console.warn(`[wechat] Account "${accountId}" login expired — attempting re-login`);
-				await this.ensureLoggedIn(accountId, client);
-			}
-		} catch (err) {
-			console.error(`[wechat] Health check failed for "${accountId}":`, err);
-		}
-	}
-	resolveAccounts() {
-		const accounts = [];
-		const rawPort = Number(process.env.ELIZA_WECHAT_WEBHOOK_PORT);
-		const defaultPort = (Number.isFinite(rawPort) && rawPort > 0 ? rawPort : void 0) ?? this.config.webhookPort ?? 18790;
-		const defaultDevice = this.config.deviceType ?? "ipad";
-		if (this.config.accounts) for (const [id, acc] of Object.entries(this.config.accounts)) {
-			if (acc.enabled === false) continue;
-			accounts.push({
-				id,
-				apiKey: acc.apiKey,
-				proxyUrl: acc.proxyUrl,
-				deviceType: acc.deviceType ?? defaultDevice,
-				webhookPort: acc.webhookPort ?? defaultPort,
-				wcId: acc.wcId,
-				nickName: acc.nickName
-			});
-		}
-		else if (this.config.apiKey && this.config.proxyUrl) accounts.push({
-			id: "default",
-			apiKey: this.config.apiKey,
-			proxyUrl: this.config.proxyUrl,
-			deviceType: defaultDevice,
-			webhookPort: defaultPort
-		});
-		return accounts;
-	}
-};
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-export { WechatChannel };

package/dist/index.d.ts

@@ -1,173 +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
-//#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
-//#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
-//#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
-//#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
-//#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
-//#region src/index.d.ts
-declare const WECHAT_PLUGIN_PACKAGE: "@elizaos/plugin-wechat";
-declare function isWechatConnectorConfigured(config: WechatConfig | Record<string, unknown> | null | undefined): boolean;
-interface Plugin {
-  name: string;
-  description: string;
-  init?: (config: Record<string, unknown>, runtime: unknown) => Promise<void | (() => Promise<void>)>;
-}
-declare const wechatPlugin: Plugin;
-//#endregion
-export { Bot, Plugin, ProxyClient, ReplyDispatcher, WECHAT_PLUGIN_PACKAGE, WechatChannel, type WechatConfig, type WechatMessageContext, wechatPlugin as default, wechatPlugin, deliverIncomingWechatMessage, isWechatConnectorConfigured };