@elizaos/plugin-wechat 2.0.0-alpha.537

package/README.md

@@ -0,0 +1,26 @@
+# @elizaos/plugin-wechat
+
+WeChat connector plugin for [elizaOS](https://github.com/elizaOS/eliza) via proxy API.
+
+## Features
+- Text and image messaging
+- DM and group support
+- Multi-account support
+- QR code login flow
+- Webhook-based message delivery
+
+## Install
+
+```bash
+npx elizaos plugins add @elizaos/plugin-wechat
+```
+
+## Configuration
+
+| Env Var | Description |
+|---------|-------------|
+| `WECHAT_API_KEY` | Proxy service API key |
+| `WECHAT_WEBHOOK_PORT` | Webhook listener port (default: 18790) |
+
+## License
+MIT

package/dist/bot.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,49 @@
+//#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

@@ -0,0 +1,207 @@
+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

@@ -0,0 +1,28 @@
+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 };

package/dist/channel.js

@@ -0,0 +1,194 @@
+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

@@ -0,0 +1,173 @@
+//#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 };