@elizaos/plugin-wechat 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/index.js

@@ -0,0 +1,1304 @@
+// src/index.ts
+import {
+  getConnectorAccountManager,
+  stringToUuid as stringToUuid2
+} from "@elizaos/core";
+
+// src/bot.ts
+var DEFAULT_DEDUP_WINDOW_MS = 30 * 60 * 1e3;
+var DEDUP_MAX_ENTRIES = 1e3;
+var DEDUP_CLEANUP_INTERVAL_MS = 5 * 60 * 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;
+    }
+    void 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();
+  }
+};
+
+// src/callback-server.ts
+import { timingSafeEqual } from "crypto";
+import {
+  createServer
+} from "http";
+var WECHAT_TYPE_MAP = {
+  // Private message types
+  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" },
+  // Group message types
+  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" }
+};
+var 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 payload = JSON.parse(body);
+        const message = normalizePayload(payload);
+        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 address = server.address();
+  const listeningPort = 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 \u2014 webhook server failed to start`
+      );
+    } else {
+      console.error(`[wechat] Webhook server error:`, err);
+    }
+  });
+  if (signal) {
+    signal.addEventListener(
+      "abort",
+      () => {
+        void 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 mediaTypes = /* @__PURE__ */ new Set(["image", "voice", "video", "file"]);
+  const hasMedia = mediaTypes.has(msgType);
+  const imageUrl = hasMedia ? 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
+  };
+}
+
+// src/proxy-client.ts
+var SUCCESS = 1e3;
+var LOGIN_NEEDED = 1001;
+var 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;
+        }
+        const json = await res.json();
+        return json;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const delay = Math.min(1e3 * 2 ** attempt, 8e3);
+        await sleep(delay);
+      }
+    }
+    throw lastError ?? 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 \u2014 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;
+}
+
+// src/reply-dispatcher.ts
+var 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;
+  }
+};
+
+// src/utils/qrcode.ts
+function displayQRUrl(url) {
+  console.log("");
+  console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551  Scan this QR code with WeChat to login  \u2551");
+  console.log("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  console.log(`\u2551  ${url}`);
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  console.log("");
+  console.log("Open the URL above in your browser to see the QR code.");
+  console.log("");
+}
+
+// src/channel.ts
+var HEALTH_CHECK_INTERVAL_MS = 6e4;
+var LOGIN_POLL_INTERVAL_MS = 5e3;
+var 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;
+      }
+    }
+  }
+  getAccountIds() {
+    return Array.from(this.accounts.keys());
+  }
+  async listContacts(accountId) {
+    const entry = this.accounts.get(accountId);
+    if (!entry) throw new Error(`Unknown account: ${accountId}`);
+    return entry.client.getContacts();
+  }
+  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 \u2014 generating QR code...`
+    );
+    const qrUrl = await client.getQRCode();
+    displayQRUrl(qrUrl);
+    const timeoutMs = this.config.loginTimeoutMs ?? LOGIN_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await sleep2(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 {
+        const status = await client.getStatus();
+        if (status.loginState !== "logged_in") {
+          console.warn(
+            `[wechat] Account "${accountId}" login expired \u2014 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 envPort = Number.isFinite(rawPort) && rawPort > 0 ? rawPort : void 0;
+    const defaultPort = envPort ?? 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 sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/connector-account-provider.ts
+var WECHAT_PROVIDER_ID = "wechat";
+var WECHAT_DEFAULT_ACCOUNT_ID = "default";
+function getWechatConfig(runtime) {
+  const character = runtime.character?.settings;
+  return character?.connectors?.wechat ?? character?.wechat;
+}
+function listWechatAccounts(runtime) {
+  const config = getWechatConfig(runtime);
+  const result = [];
+  if (!config) {
+    const envApiKey = runtime.getSetting?.("WECHAT_API_KEY");
+    const envProxy = runtime.getSetting?.("WECHAT_PROXY_URL");
+    if (envApiKey?.trim() || envProxy?.trim()) {
+      result.push({
+        id: WECHAT_DEFAULT_ACCOUNT_ID,
+        enabled: true,
+        apiKeyConfigured: Boolean(envApiKey?.trim()),
+        proxyUrl: envProxy?.trim() || void 0
+      });
+    }
+    return result;
+  }
+  if (config.enabled === false) {
+    if (config.apiKey?.trim() || config.accounts) {
+      result.push({
+        id: WECHAT_DEFAULT_ACCOUNT_ID,
+        enabled: false,
+        apiKeyConfigured: Boolean(config.apiKey?.trim()),
+        proxyUrl: config.proxyUrl
+      });
+    }
+    return result;
+  }
+  if (config.apiKey?.trim()) {
+    result.push({
+      id: WECHAT_DEFAULT_ACCOUNT_ID,
+      enabled: true,
+      apiKeyConfigured: true,
+      proxyUrl: config.proxyUrl
+    });
+  }
+  if (config.accounts && typeof config.accounts === "object") {
+    for (const [id, account] of Object.entries(config.accounts)) {
+      if (!id) continue;
+      result.push({
+        id: id.trim().toLowerCase(),
+        enabled: account.enabled !== false,
+        apiKeyConfigured: Boolean(account.apiKey?.trim()),
+        proxyUrl: account.proxyUrl,
+        wcId: account.wcId,
+        nickName: account.nickName,
+        name: account.name
+      });
+    }
+  }
+  return result;
+}
+function toConnectorAccount(account) {
+  const now = Date.now();
+  return {
+    id: account.id,
+    provider: WECHAT_PROVIDER_ID,
+    label: account.name ?? account.nickName ?? account.id,
+    role: "AGENT",
+    purpose: ["messaging"],
+    accessGate: "open",
+    status: account.enabled && account.apiKeyConfigured ? "connected" : "disabled",
+    externalId: account.wcId || void 0,
+    displayHandle: account.nickName || void 0,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      proxyUrl: account.proxyUrl ?? "",
+      wcId: account.wcId ?? "",
+      nickName: account.nickName ?? ""
+    }
+  };
+}
+function createWechatConnectorAccountProvider(runtime) {
+  return {
+    provider: WECHAT_PROVIDER_ID,
+    label: "WeChat",
+    listAccounts: async (_manager) => {
+      const accounts = listWechatAccounts(runtime);
+      return accounts.map(toConnectorAccount);
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: WECHAT_PROVIDER_ID,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: WECHAT_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {
+    }
+  };
+}
+
+// src/runtime-bridge.ts
+import { stringToUuid } from "@elizaos/core";
+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") {
+    const result = await runtime.elizaOS.sendMessage(
+      options.runtime,
+      incomingMemory,
+      { onResponse }
+    );
+    await maybeHandleResponseContent(result, replyDelivered, onResponse);
+    return;
+  }
+  if (typeof runtime.messageService?.handleMessage === "function") {
+    const result = await runtime.messageService.handleMessage(
+      options.runtime,
+      incomingMemory,
+      onResponse
+    );
+    await maybeHandleResponseContent(result, 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);
+}
+
+// src/index.ts
+var WECHAT_PLUGIN_PACKAGE = "@elizaos/plugin-wechat";
+function isWechatConnectorConfigured(config) {
+  if (!config || config.enabled === false) {
+    return false;
+  }
+  if (config.apiKey) {
+    return true;
+  }
+  const accounts = config.accounts;
+  if (accounts && typeof accounts === "object") {
+    return Object.values(
+      accounts
+    ).some((account) => {
+      if (account.enabled === false) {
+        return false;
+      }
+      return Boolean(account.apiKey);
+    });
+  }
+  return false;
+}
+var channel = null;
+function readRuntimeSetting(runtime, key) {
+  const value = runtime.getSetting?.(key);
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveWechatConfig(config, runtime) {
+  const explicit = config?.connectors?.wechat;
+  if (explicit) return explicit;
+  const apiKey = readRuntimeSetting(runtime, "WECHAT_API_KEY");
+  const proxyUrl = readRuntimeSetting(runtime, "WECHAT_PROXY_URL");
+  if (!apiKey && !proxyUrl) return void 0;
+  return {
+    apiKey,
+    proxyUrl
+  };
+}
+function normalizeConnectorLimit(limit, fallback = 50) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(limit), 200);
+}
+function getConfiguredAccountIds(config) {
+  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, target) {
+  const metadata = target?.metadata;
+  const accountId = typeof metadata?.accountId === "string" && metadata.accountId.trim() ? metadata.accountId.trim() : void 0;
+  if (accountId) {
+    return accountId;
+  }
+  return channel?.getAccountIds()[0] ?? getConfiguredAccountIds(config)[0] ?? "default";
+}
+function wechatTarget(accountId, wxid, name, kind, score = 0.55) {
+  return {
+    target: {
+      source: "wechat",
+      channelId: wxid,
+      roomId: stringToUuid2(`wechat:room:${accountId}:${wxid}`),
+      metadata: { accountId }
+    },
+    label: name || wxid,
+    kind,
+    score,
+    contexts: ["social", "connectors"],
+    metadata: { accountId, wxid }
+  };
+}
+async function listWechatTargets(config) {
+  if (!channel) {
+    return [];
+  }
+  const targets = [];
+  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, query, limit) {
+  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, config) {
+  const connectorRuntime = runtime;
+  const sendHandler = async (_runtime, target, content) => {
+    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) => {
+        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, params) => {
+        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) => 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, params) => {
+        const limit = normalizeConnectorLimit(params.limit);
+        const registration = connectorRuntime.getMessageConnectors?.().find((connector) => connector.source === "wechat");
+        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);
+}
+var wechatPlugin = {
+  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, runtime) {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(
+        createWechatConnectorAccountProvider(runtime)
+      );
+    } 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 \u2014 skipping");
+      return;
+    }
+    if (wechatConfig.enabled === false) {
+      console.log("[wechat] Plugin disabled via config");
+      return;
+    }
+    channel = new WechatChannel({
+      config: wechatConfig,
+      onMessage: async (accountId, msg) => {
+        await deliverIncomingWechatMessage({
+          runtime,
+          accountId,
+          message: msg,
+          sendText: async (replyAccountId, to, text) => {
+            if (!channel) {
+              throw new Error("[wechat] Channel is not available for replies");
+            }
+            await channel.sendText(replyAccountId, to, text);
+          }
+        });
+      }
+    });
+    await channel.start();
+    registerWechatMessageConnector(runtime, wechatConfig);
+    console.log("[wechat] Plugin initialized");
+    return async () => {
+      if (channel) {
+        await channel.stop();
+        channel = null;
+        console.log("[wechat] Plugin stopped");
+      }
+    };
+  },
+  async dispose() {
+    if (channel) {
+      await channel.stop();
+      channel = null;
+      console.log("[wechat] Plugin disposed");
+    }
+  }
+};
+var index_default = wechatPlugin;
+export {
+  Bot,
+  ProxyClient,
+  ReplyDispatcher,
+  WECHAT_PLUGIN_PACKAGE,
+  WechatChannel,
+  index_default as default,
+  deliverIncomingWechatMessage,
+  isWechatConnectorConfigured,
+  wechatPlugin
+};
+//# sourceMappingURL=index.js.map