engine7 7.1.41 → 7.1.42

package/dist/cli.mjs

@@ -14,6 +14,951 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/channels/wechat.ts
+var wechat_exports = {};
+__export(wechat_exports, {
+  WechatAdapter: () => WechatAdapter,
+  wechatQrLogin: () => wechatQrLogin
+});
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { promises as dns } from "dns";
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function pkcs7Pad(data, blockSize = 16) {
+  const pad = blockSize - data.length % blockSize;
+  return Buffer.concat([data, Buffer.alloc(pad, pad)]);
+}
+function pkcs7Unpad(data) {
+  if (!data.length) return data;
+  const pad = data[data.length - 1];
+  if (pad < 1 || pad > 16 || pad > data.length) return data;
+  return data.subarray(0, data.length - pad);
+}
+function aesEncrypt(plaintext, key) {
+  const c = crypto.createCipheriv("aes-128-ecb", key, null);
+  c.setAutoPadding(false);
+  return Buffer.concat([c.update(pkcs7Pad(plaintext)), c.final()]);
+}
+function aesDecrypt(ciphertext, key) {
+  const d = crypto.createDecipheriv("aes-128-ecb", key, null);
+  d.setAutoPadding(false);
+  return pkcs7Unpad(Buffer.concat([d.update(ciphertext), d.final()]));
+}
+function parseAesKey(b64) {
+  const decoded = Buffer.from(b64, "base64");
+  if (decoded.length === 16) return decoded;
+  if (decoded.length === 32) {
+    const text = decoded.toString("ascii");
+    if (/^[0-9a-fA-F]+$/.test(text)) return Buffer.from(text, "hex");
+  }
+  throw new Error(`unexpected aes_key format (${decoded.length} bytes)`);
+}
+function randomUin() {
+  return Buffer.from(String(crypto.randomBytes(4).readUInt32BE(0)), "utf-8").toString("base64");
+}
+async function isNetworkUp(hostname) {
+  try {
+    await dns.resolve(hostname, "A");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildHeaders(token) {
+  return {
+    "Content-Type": "application/json",
+    "AuthorizationType": "ilink_bot_token",
+    "X-WECHAT-UIN": randomUin(),
+    "iLink-App-Id": ILINK_APP_ID,
+    "iLink-App-ClientVersion": String(ILINK_APP_CLIENT_VERSION),
+    "Authorization": `Bearer ${token}`
+  };
+}
+async function apiPost(baseUrl, endpoint, payload, token, timeoutMs) {
+  const body = JSON.stringify({ ...payload, base_info: { channel_version: CHANNEL_VERSION } });
+  const url = `${baseUrl.replace(/\/$/, "")}/${endpoint}`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, { method: "POST", headers: buildHeaders(token), body, signal: ctrl.signal });
+    const text = await resp.text();
+    if (!resp.ok) throw new Error(`iLink POST ${endpoint} HTTP ${resp.status}: ${text.slice(0, 200)}`);
+    return JSON.parse(text);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function assertCdnUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Bad media URL: ${url}`);
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) throw new Error(`Bad scheme: ${parsed.protocol}`);
+  if (!CDN_ALLOWLIST.has(parsed.hostname)) throw new Error(`SSRF: host ${parsed.hostname} not in allowlist`);
+}
+function cdnDownloadUrl(base, param) {
+  return `${base.replace(/\/$/, "")}/download?encrypted_query_param=${encodeURIComponent(param)}`;
+}
+async function downloadBytes(url, timeoutMs) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, { signal: ctrl.signal });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    return Buffer.from(await resp.arrayBuffer());
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function downloadAndDecryptMedia(cdnBase, encParam, aesKeyB64, fullUrl, timeoutSec) {
+  let raw;
+  if (encParam) {
+    raw = await downloadBytes(cdnDownloadUrl(cdnBase, encParam), timeoutSec * 1e3);
+  } else if (fullUrl) {
+    assertCdnUrl(fullUrl);
+    raw = await downloadBytes(fullUrl, timeoutSec * 1e3);
+  } else {
+    throw new Error("media: no encrypt_query_param or full_url");
+  }
+  if (aesKeyB64) raw = aesDecrypt(raw, parseAesKey(aesKeyB64));
+  return raw;
+}
+function cdnUploadUrl(base, uploadParam, filekey) {
+  return `${base.replace(/\/$/, "")}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(filekey)}`;
+}
+async function uploadCiphertext(uploadUrl, ciphertext) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 12e4);
+  try {
+    console.log(`[wechat:cdn] upload start: url=${uploadUrl.slice(0, 120)}... ciphertextLen=${ciphertext.length}`);
+    const resp = await fetch(uploadUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: new Uint8Array(ciphertext),
+      signal: ctrl.signal
+    });
+    console.log(`[wechat:cdn] upload resp: status=${resp.status} headers=${JSON.stringify(Object.fromEntries(resp.headers.entries()))}`);
+    if (resp.status === 200) {
+      const param = resp.headers.get("x-encrypted-param");
+      const bodyText = await resp.text();
+      if (param) {
+        return param;
+      }
+      throw new Error(`CDN upload missing x-encrypted-param: ${bodyText.slice(0, 200)}`);
+    }
+    const text = await resp.text();
+    throw new Error(`CDN upload HTTP ${resp.status}: ${text.slice(0, 200)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function safeId(id, keep = 8) {
+  return id.length <= keep ? id : id.slice(0, keep) + "...";
+}
+function isSessionExpired(ret, errcode, errmsg) {
+  if (ret === SESSION_EXPIRED_ERRCODE || errcode === SESSION_EXPIRED_ERRCODE) return true;
+  if ((ret === RATE_LIMIT_ERRCODE || errcode === RATE_LIMIT_ERRCODE) && (errmsg || "").toLowerCase() === "unknown error") return true;
+  return false;
+}
+function extractText(itemList) {
+  for (const item of itemList) {
+    if (item.type === ITEM_TEXT) {
+      const text = String(item.text_item?.text || "");
+      const ref = item.ref_msg || {};
+      const refItem = ref.message_item || {};
+      if ([ITEM_IMAGE, ITEM_VIDEO, ITEM_FILE, ITEM_VOICE].includes(refItem.type)) {
+        const title = ref.title || "";
+        return `${title ? `[\u5F15\u7528\u5A92\u4F53: ${title}]
+` : "[\u5F15\u7528\u5A92\u4F53]\n"}${text}`.trim();
+      }
+      if (refItem && Object.keys(refItem).length > 0) {
+        const parts = [];
+        if (ref.title) parts.push(String(ref.title));
+        const rt = extractText([refItem]);
+        if (rt) parts.push(rt);
+        if (parts.length) return `[\u5F15\u7528: ${parts.join(" | ")}]
+${text}`.trim();
+      }
+      return text;
+    }
+  }
+  for (const item of itemList) {
+    if (item.type === ITEM_VOICE) {
+      const vt = String(item.voice_item?.text || "");
+      if (vt) return vt;
+    }
+  }
+  return "";
+}
+function guessChatType(msg, accountId) {
+  const roomId = String(msg.room_id || msg.chat_room_id || "").trim();
+  const toId = String(msg.to_user_id || "").trim();
+  const isGroup = !!roomId || !!toId && !!accountId && toId !== accountId && msg.msg_type === 1;
+  return isGroup ? { type: "group", chatId: roomId || toId || String(msg.from_user_id || "") } : { type: "dm", chatId: String(msg.from_user_id || "") };
+}
+function mimeFromFilename(filename) {
+  const ext = path.extname(filename).toLowerCase();
+  const map = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".silk": "audio/silk",
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".zip": "application/zip",
+    ".txt": "text/plain"
+  };
+  return map[ext] || "application/octet-stream";
+}
+function formatForWechat(content) {
+  let lines = content.split("\n");
+  lines = lines.map((l) => {
+    const m = l.match(/^#{1,4}\s+(.*)/);
+    return m ? `\u3010${m[1].trim()}\u3011` : l;
+  });
+  const result = [];
+  for (const line of lines) {
+    if (line.trim().startsWith("|") && line.trim().endsWith("|")) {
+      if (/^\|[\s:-]+\|$/.test(line.trim())) continue;
+      const cells = line.trim().slice(1, -1).split("|").map((c) => c.trim());
+      if (cells.every((c) => /^[-:]+$/.test(c))) continue;
+      result.push(`\u2022 ${cells.join(" | ")}`);
+    } else {
+      result.push(line);
+    }
+  }
+  const out = [];
+  let prevBlank = false;
+  for (const l of result) {
+    if (!l.trim() && prevBlank) continue;
+    out.push(l);
+    prevBlank = !l.trim();
+  }
+  return out.join("\n").trim();
+}
+function splitText(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > maxLen) {
+    let idx = remaining.lastIndexOf("\n", maxLen);
+    if (idx <= 0) idx = remaining.lastIndexOf(" ", maxLen);
+    if (idx <= 0) idx = maxLen;
+    chunks.push(remaining.slice(0, idx).trim());
+    remaining = remaining.slice(idx).trim();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks.filter((c) => c);
+}
+function loadSyncBuf(stateDir, accountId) {
+  try {
+    const fp = path.join(stateDir, "weixin", `${accountId}.sync.json`);
+    if (fs.existsSync(fp)) return String(JSON.parse(fs.readFileSync(fp, "utf-8")).sync_buf || "");
+  } catch {
+  }
+  return "";
+}
+function saveSyncBuf(stateDir, accountId, buf) {
+  try {
+    const fp = path.join(stateDir, "weixin", `${accountId}.sync.json`);
+    const dir = path.dirname(fp);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(fp, JSON.stringify({ sync_buf: buf }));
+  } catch {
+  }
+}
+async function wechatQrLogin(options) {
+  const botType = options?.botType || "3";
+  const timeoutSeconds = options?.timeoutSeconds || 480;
+  const stateDir = options?.stateDir || path.join(os.homedir?.() || "/tmp", ".engine7");
+  console.log("[wechat] Fetching QR code from iLink...");
+  let qrResp;
+  try {
+    qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
+  } catch (err) {
+    console.error(`[wechat] Failed to fetch QR code: ${err.message}`);
+    return null;
+  }
+  const qrcodeValue = String(qrResp?.qrcode || "");
+  const qrcodeUrl = String(qrResp?.qrcode_img_content || "");
+  if (!qrcodeValue) {
+    console.error("[wechat] QR response missing qrcode field");
+    return null;
+  }
+  const qrScanData = qrcodeUrl || qrcodeValue;
+  console.log("\n========== \u5FAE\u4FE1\u626B\u7801\u767B\u5F55 ==========");
+  if (qrcodeUrl) {
+    console.log(`\u626B\u7801\u94FE\u63A5: ${qrcodeUrl}`);
+  }
+  console.log("\u8BF7\u7528\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801\uFF08\u6216\u6253\u5F00\u4E0A\u9762\u7684\u94FE\u63A5\uFF09:");
+  console.log("===================================\n");
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  let currentBaseUrl = ILINK_BASE_URL;
+  let refreshCount = 0;
+  while (Date.now() < deadline) {
+    let statusResp;
+    try {
+      statusResp = await apiGet(currentBaseUrl, `${EP_GET_QR_STATUS}?qrcode=${qrcodeValue}`, "", QR_TIMEOUT_MS);
+    } catch {
+      await sleep2(1e3);
+      continue;
+    }
+    const status = String(statusResp?.status || "wait");
+    if (status === "wait") {
+      process.stdout.write(".");
+    } else if (status === "scaned") {
+      console.log("\n\u5DF2\u626B\u7801\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u91CC\u786E\u8BA4...");
+    } else if (status === "scaned_but_redirect") {
+      const redirectHost = String(statusResp?.redirect_host || "");
+      if (redirectHost) currentBaseUrl = `https://${redirectHost}`;
+    } else if (status === "expired") {
+      refreshCount++;
+      if (refreshCount > 3) {
+        console.log("\n\u4E8C\u7EF4\u7801\u591A\u6B21\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u767B\u5F55\u3002");
+        return null;
+      }
+      console.log(`
+\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u5237\u65B0\u4E2D... (${refreshCount}/3)`);
+      try {
+        qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
+        const newQrValue = String(qrResp?.qrcode || "");
+        const newQrUrl = String(qrResp?.qrcode_img_content || "");
+        if (newQrUrl) console.log(`\u65B0\u626B\u7801\u94FE\u63A5: ${newQrUrl}`);
+      } catch (err) {
+        console.error(`[wechat] QR refresh failed: ${err.message}`);
+        return null;
+      }
+    } else if (status === "confirmed") {
+      const accountId = String(statusResp?.ilink_bot_id || "");
+      const token = String(statusResp?.bot_token || "");
+      const baseUrl = String(statusResp?.baseurl || ILINK_BASE_URL);
+      const userId = String(statusResp?.ilink_user_id || "");
+      if (!accountId || !token) {
+        console.error("[wechat] QR confirmed but credential payload incomplete");
+        return null;
+      }
+      if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+      const credFile = path.join(stateDir, `weixin-${accountId}.json`);
+      fs.writeFileSync(credFile, JSON.stringify({ accountId, token, baseUrl, userId }, null, 2), "utf8");
+      console.log(`
+\u2705 \u5FAE\u4FE1\u767B\u5F55\u6210\u529F!`);
+      console.log(`   accountId: ${accountId}`);
+      console.log(`   \u51ED\u8BC1\u5DF2\u4FDD\u5B58: ${credFile}`);
+      console.log(`
+\u8BF7\u5C06\u4EE5\u4E0B\u914D\u7F6E\u6DFB\u52A0\u5230 xiaoke.json:`);
+      console.log(JSON.stringify({
+        wechat: {
+          token,
+          accountId,
+          baseUrl: baseUrl !== ILINK_BASE_URL ? baseUrl : void 0
+        }
+      }, null, 2));
+      return { accountId, token, baseUrl, userId };
+    }
+    await sleep2(1e3);
+  }
+  console.log("\n[wechat] QR login timed out");
+  return null;
+}
+async function apiGet(baseUrl, endpoint, _token, timeoutMs) {
+  const url = `${baseUrl.replace(/\/$/, "")}/${endpoint.replace(/^\//, "")}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    return await resp.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var ILINK_BASE_URL, WEIXIN_CDN_BASE_URL, ILINK_APP_ID, CHANNEL_VERSION, ILINK_APP_CLIENT_VERSION, EP_GET_UPDATES, EP_SEND_MESSAGE, EP_SEND_TYPING, EP_GET_CONFIG, EP_GET_UPLOAD_URL, LONG_POLL_TIMEOUT_MS, API_TIMEOUT_MS, MAX_MESSAGE_LENGTH, MAX_CONSECUTIVE_FAILURES, RETRY_DELAY_MS, BACKOFF_DELAY_MS, DISCONNECTED_THRESHOLD, DISCONNECTED_POLL_INTERVAL, SESSION_EXPIRED_ERRCODE, RATE_LIMIT_ERRCODE, SEND_CHUNK_DELAY_MS, SEND_CHUNK_RETRIES, SEND_CHUNK_RETRY_DELAY_MS, ITEM_TEXT, ITEM_IMAGE, ITEM_VOICE, ITEM_FILE, ITEM_VIDEO, MSG_TYPE_BOT, MSG_STATE_FINISH, MEDIA_IMAGE, MEDIA_VIDEO, MEDIA_FILE, MEDIA_VOICE, CDN_ALLOWLIST, ContextTokenStore, MessageDeduplicator, WechatAdapter, EP_GET_BOT_QR, EP_GET_QR_STATUS, QR_TIMEOUT_MS;
+var init_wechat = __esm({
+  "src/channels/wechat.ts"() {
+    "use strict";
+    ILINK_BASE_URL = "https://ilinkai.weixin.qq.com";
+    WEIXIN_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+    ILINK_APP_ID = "bot";
+    CHANNEL_VERSION = "2.2.0";
+    ILINK_APP_CLIENT_VERSION = 2 << 16 | 2 << 8 | 0;
+    EP_GET_UPDATES = "ilink/bot/getupdates";
+    EP_SEND_MESSAGE = "ilink/bot/sendmessage";
+    EP_SEND_TYPING = "ilink/bot/sendtyping";
+    EP_GET_CONFIG = "ilink/bot/getconfig";
+    EP_GET_UPLOAD_URL = "ilink/bot/getuploadurl";
+    LONG_POLL_TIMEOUT_MS = 35e3;
+    API_TIMEOUT_MS = 15e3;
+    MAX_MESSAGE_LENGTH = 2e3;
+    MAX_CONSECUTIVE_FAILURES = 3;
+    RETRY_DELAY_MS = 2e3;
+    BACKOFF_DELAY_MS = 3e4;
+    DISCONNECTED_THRESHOLD = 5;
+    DISCONNECTED_POLL_INTERVAL = 5e3;
+    SESSION_EXPIRED_ERRCODE = -14;
+    RATE_LIMIT_ERRCODE = -2;
+    SEND_CHUNK_DELAY_MS = 1500;
+    SEND_CHUNK_RETRIES = 4;
+    SEND_CHUNK_RETRY_DELAY_MS = 1e3;
+    ITEM_TEXT = 1;
+    ITEM_IMAGE = 2;
+    ITEM_VOICE = 3;
+    ITEM_FILE = 4;
+    ITEM_VIDEO = 5;
+    MSG_TYPE_BOT = 2;
+    MSG_STATE_FINISH = 2;
+    MEDIA_IMAGE = 1;
+    MEDIA_VIDEO = 2;
+    MEDIA_FILE = 3;
+    MEDIA_VOICE = 4;
+    CDN_ALLOWLIST = /* @__PURE__ */ new Set([
+      "novac2c.cdn.weixin.qq.com",
+      "ilinkai.weixin.qq.com",
+      "wx.qlogo.cn",
+      "thirdwx.qlogo.cn",
+      "res.wx.qq.com",
+      "mmbiz.qpic.cn",
+      "mmbiz.qlogo.cn"
+    ]);
+    ContextTokenStore = class {
+      cache = /* @__PURE__ */ new Map();
+      filePath;
+      constructor(stateDir, accountId) {
+        this.filePath = path.join(stateDir, "weixin", `${accountId}.context-tokens.json`);
+      }
+      k(a, p) {
+        return `${a}:${p}`;
+      }
+      restore() {
+        try {
+          if (fs.existsSync(this.filePath)) {
+            for (const [k, v] of Object.entries(JSON.parse(fs.readFileSync(this.filePath, "utf-8"))))
+              this.cache.set(k, String(v));
+          }
+        } catch {
+        }
+      }
+      save() {
+        try {
+          const dir = path.dirname(this.filePath);
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          const obj = {};
+          this.cache.forEach((v, k) => obj[k] = v);
+          fs.writeFileSync(this.filePath, JSON.stringify(obj));
+        } catch {
+        }
+      }
+      get(a, p) {
+        return p !== void 0 ? this.cache.get(this.k(a, p)) : this.cache.get(a);
+      }
+      set(a, pOrT, t) {
+        if (t !== void 0) this.cache.set(this.k(a, pOrT), t);
+        else this.cache.set(a, pOrT);
+        this.save();
+      }
+      delete(a, p) {
+        const key = p !== void 0 ? this.k(a, p) : a;
+        this.cache.delete(key);
+        this.save();
+      }
+    };
+    MessageDeduplicator = class {
+      ids = /* @__PURE__ */ new Map();
+      ttlMs;
+      constructor(ttlMs = 3e5) {
+        this.ttlMs = ttlMs;
+      }
+      isDuplicate(id) {
+        const now = Date.now();
+        for (const [k, ts] of this.ids) {
+          if (now - ts > this.ttlMs) this.ids.delete(k);
+        }
+        if (this.ids.has(id)) return true;
+        this.ids.set(id, now);
+        return false;
+      }
+    };
+    WechatAdapter = class {
+      name = "wechat";
+      suppressToolDisplay = true;
+      // 微信不支持 tool display（rate limit 太严）
+      config;
+      messageHandler = null;
+      tokenStore;
+      dedup = new MessageDeduplicator();
+      running = false;
+      connected = false;
+      typingTasks = /* @__PURE__ */ new Map();
+      lastSendAt = 0;
+      // 全局发送节流
+      typingTicketCache = /* @__PURE__ */ new Map();
+      // typing ticket 缓存（10min TTL）
+      baseUrl;
+      cdnBaseUrl;
+      stateDir;
+      constructor(config) {
+        this.config = config;
+        this.baseUrl = config.baseUrl?.replace(/\/$/, "") || ILINK_BASE_URL;
+        this.cdnBaseUrl = config.cdnBaseUrl?.replace(/\/$/, "") || WEIXIN_CDN_BASE_URL;
+        this.stateDir = config.stateDir || path.join(os.homedir?.() || "/tmp", ".engine7");
+        if (!fs.existsSync(this.stateDir)) fs.mkdirSync(this.stateDir, { recursive: true });
+      }
+      // --- ChannelAdapter interface ---
+      onMessage(handler) {
+        this.messageHandler = handler;
+      }
+      async connect() {
+        if (!this.config.token) throw new Error("WechatAdapter: token is required");
+        if (!this.config.accountId) throw new Error("WechatAdapter: accountId is required");
+        this.tokenStore = new ContextTokenStore(this.stateDir, this.config.accountId);
+        this.tokenStore.restore();
+        this.running = true;
+        this.connected = true;
+        this.pollLoop().catch((err) => {
+          console.error(`[wechat] poll loop crashed: ${err.message}`);
+          this.connected = false;
+        });
+        console.log(`[wechat] Connected account=${safeId(this.config.accountId)} base=${this.baseUrl}`);
+        if (this.config.groupPolicy && this.config.groupPolicy !== "disabled") {
+          console.warn(`[wechat] groupPolicy=${this.config.groupPolicy} \u2014 iLink bot accounts typically cannot join ordinary WeChat groups`);
+        }
+      }
+      async disconnect() {
+        this.running = false;
+        this.connected = false;
+        console.log(`[wechat] Disconnected`);
+      }
+      // --- Streaming preview（微信没有编辑API，只在finish时发一次） ---
+      async sendPreview(channelId, _content, _agentName) {
+        this.previewSent = false;
+        return { channelId, messageId: `preview-${Date.now()}` };
+      }
+      previewSent = false;
+      // 防止 freeze() 重复触发发送
+      async editPreview(_handle, _content, _agentName, _isFinal) {
+      }
+      async deletePreview(_handle) {
+      }
+      async send(target, message, options) {
+        const formatted = formatForWechat(message);
+        if (!formatted.trim()) return;
+        const elapsed = Date.now() - this.lastSendAt;
+        if (elapsed < 3e3) await sleep2(3e3 - elapsed);
+        const chunks = splitText(formatted, MAX_MESSAGE_LENGTH);
+        const contextToken = this.tokenStore.get(this.config.accountId, target);
+        for (let i = 0; i < chunks.length; i++) {
+          await this.sendTextChunk(target, chunks[i], contextToken);
+          this.lastSendAt = Date.now();
+          if (i < chunks.length - 1) await sleep2(SEND_CHUNK_DELAY_MS);
+        }
+      }
+      async sendFile(target, message, attachment) {
+        const filePath = attachment.path;
+        if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+        const plaintext = fs.readFileSync(filePath);
+        const mediaType = this.guessMediaType(filePath, attachment.mimeType);
+        const filekey = crypto.randomBytes(16).toString("hex");
+        const aesKey = crypto.randomBytes(16);
+        const rawsize = plaintext.length;
+        const rawfilemd5 = crypto.createHash("md5").update(plaintext).digest("hex");
+        const ciphertext = aesEncrypt(plaintext, aesKey);
+        const aeskeyHex = aesKey.toString("hex");
+        const uploadResp = await apiPost(this.baseUrl, EP_GET_UPLOAD_URL, {
+          to_user_id: target,
+          media_type: mediaType,
+          filekey,
+          rawsize,
+          rawfilemd5,
+          filesize: ciphertext.length,
+          aeskey: aeskeyHex,
+          no_need_thumb: true
+        }, this.config.token, API_TIMEOUT_MS);
+        const uploadFullUrl = String(uploadResp.upload_full_url || "");
+        const uploadParam = String(uploadResp.upload_param || "");
+        console.log(`[wechat] sendFile getUploadUrl: mediaType=${mediaType} size=${rawsize} uploadFullUrl=${uploadFullUrl ? "YES" : "NO"} uploadParam=${uploadParam ? uploadParam.slice(0, 40) + "..." : "NO"} resp=${JSON.stringify(uploadResp).slice(0, 200)}`);
+        if (!uploadFullUrl && !uploadParam) {
+          throw new Error(`getUploadUrl returned neither upload_param nor upload_full_url: ${JSON.stringify(uploadResp).slice(0, 200)}`);
+        }
+        const uploadUrl = uploadFullUrl || cdnUploadUrl(this.cdnBaseUrl, uploadParam, filekey);
+        const encryptedQueryParam = await uploadCiphertext(uploadUrl, ciphertext);
+        const aesKeyForApi = Buffer.from(aeskeyHex, "ascii").toString("base64");
+        const mediaItem = this.buildMediaItem(mediaType, {
+          encryptedQueryParam,
+          aesKeyForApi,
+          ciphertextSize: ciphertext.length,
+          plaintextSize: rawsize,
+          filename: path.basename(filePath),
+          rawfilemd5,
+          voiceDurationSec: attachment.voiceDurationSec
+        });
+        if (message && message.trim()) {
+          const contextToken2 = this.tokenStore.get(target);
+          const clientId2 = `engine-weixin-${crypto.randomUUID().replace(/-/g, "")}`;
+          await apiPost(this.baseUrl, EP_SEND_MESSAGE, {
+            msg: {
+              from_user_id: "",
+              to_user_id: target,
+              client_id: clientId2,
+              message_type: MSG_TYPE_BOT,
+              message_state: MSG_STATE_FINISH,
+              item_list: [{ type: ITEM_TEXT, text_item: { text: this.formatMessage(message) } }],
+              ...contextToken2 ? { context_token: contextToken2 } : {}
+            }
+          }, this.config.token, API_TIMEOUT_MS);
+        }
+        const clientId = `engine-weixin-${crypto.randomUUID().replace(/-/g, "")}`;
+        const contextToken = this.tokenStore.get(target);
+        await apiPost(this.baseUrl, EP_SEND_MESSAGE, {
+          msg: {
+            from_user_id: "",
+            to_user_id: target,
+            client_id: clientId,
+            message_type: MSG_TYPE_BOT,
+            message_state: MSG_STATE_FINISH,
+            item_list: [mediaItem],
+            ...contextToken ? { context_token: contextToken } : {}
+          }
+        }, this.config.token, API_TIMEOUT_MS);
+      }
+      // --- Typing indicator ---
+      getTypingTicket(userId) {
+        const entry = this.typingTicketCache.get(userId);
+        if (!entry) return void 0;
+        if (Date.now() >= entry.expires) {
+          this.typingTicketCache.delete(userId);
+          return void 0;
+        }
+        return entry.ticket;
+      }
+      async fetchTypingTicket(target) {
+        if (!this.connected) return void 0;
+        try {
+          const ctxToken = this.tokenStore.get(this.config.accountId, target);
+          const payload = { ilink_user_id: target };
+          if (ctxToken) payload.context_token = ctxToken;
+          const resp = await apiPost(this.baseUrl, EP_GET_CONFIG, payload, this.config.token, 1e4);
+          const ticket = String(resp.typing_ticket || "");
+          if (ticket) {
+            this.typingTicketCache.set(target, { ticket, expires: Date.now() + 6e5 });
+          }
+          return ticket || void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      async sendTypingIndicator(target, status) {
+        if (!this.connected) return;
+        try {
+          let ticket = this.getTypingTicket(target);
+          if (!ticket) ticket = await this.fetchTypingTicket(target);
+          if (!ticket) return;
+          await apiPost(this.baseUrl, EP_SEND_TYPING, {
+            ilink_user_id: target,
+            typing_ticket: ticket,
+            status
+          }, this.config.token, 1e4);
+        } catch {
+        }
+      }
+      startTyping(channelId) {
+        if (this.typingTasks.has(channelId)) return;
+        this.sendTypingIndicator(channelId, 1).catch(() => {
+        });
+        const timer = setInterval(() => {
+          const state = this.typingTasks.get(channelId);
+          if (!state || state.paused) return;
+          this.sendTypingIndicator(channelId, 1).catch(() => {
+            this.stopTyping(channelId);
+          });
+        }, 8e3);
+        this.typingTasks.set(channelId, { timer, paused: false });
+      }
+      async stopTyping(channelId) {
+        const state = this.typingTasks.get(channelId);
+        if (!state) return;
+        clearInterval(state.timer);
+        this.typingTasks.delete(channelId);
+        await this.sendTypingIndicator(channelId, 2);
+      }
+      pauseTyping(channelId) {
+        const state = this.typingTasks.get(channelId);
+        if (state) state.paused = true;
+      }
+      resumeTyping(channelId) {
+        const state = this.typingTasks.get(channelId);
+        if (state) {
+          state.paused = false;
+          this.sendTypingIndicator(channelId, 1).catch(() => {
+          });
+        }
+      }
+      // --- Internal: poll loop ---
+      async pollLoop() {
+        let syncBuf = loadSyncBuf(this.stateDir, this.config.accountId);
+        let timeoutMs = LONG_POLL_TIMEOUT_MS;
+        let consecutiveFailures = 0;
+        let disconnected = false;
+        while (this.running) {
+          try {
+            const response = await apiPost(this.baseUrl, EP_GET_UPDATES, {
+              get_updates_buf: syncBuf
+            }, this.config.token, timeoutMs);
+            const suggestedTimeout = response.longpolling_timeout_ms;
+            if (typeof suggestedTimeout === "number" && suggestedTimeout > 0) timeoutMs = suggestedTimeout;
+            const ret = response.ret ?? 0;
+            const errcode = response.errcode ?? 0;
+            if (ret !== 0 || errcode !== 0) {
+              if (isSessionExpired(ret, errcode, response.errmsg)) {
+                console.error(`[wechat] Session expired; pausing 10 min`);
+                await sleep2(6e5);
+                consecutiveFailures = 0;
+                continue;
+              }
+              consecutiveFailures++;
+              if (consecutiveFailures >= DISCONNECTED_THRESHOLD && !disconnected) {
+                disconnected = true;
+                console.warn(`[wechat] \u26A0\uFE0F network disconnected \u2014 poll failing continuously`);
+              }
+              console.warn(`[wechat] getUpdates failed ret=${ret} errcode=${errcode} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+              await sleep2(consecutiveFailures >= MAX_CONSECUTIVE_FAILURES ? BACKOFF_DELAY_MS : RETRY_DELAY_MS);
+              if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) consecutiveFailures = 0;
+              continue;
+            }
+            if (disconnected) {
+              disconnected = false;
+              console.log(`[wechat] \u2705 network recovered \u2014 poll resumed successfully`);
+            }
+            consecutiveFailures = 0;
+            const newSyncBuf = String(response.get_updates_buf || "");
+            if (newSyncBuf) {
+              syncBuf = newSyncBuf;
+              saveSyncBuf(this.stateDir, this.config.accountId, syncBuf);
+            }
+            for (const message of response.msgs || []) {
+              this.processMessage(message).catch((err) => {
+                console.error(`[wechat] processMessage error from=${safeId(String(message.from_user_id || ""))}: ${err.message}`);
+              });
+            }
+          } catch (err) {
+            if (err.name === "AbortError") continue;
+            consecutiveFailures++;
+            if (consecutiveFailures >= DISCONNECTED_THRESHOLD && !disconnected) {
+              disconnected = true;
+              console.warn(`[wechat] \u26A0\uFE0F network disconnected \u2014 poll failing continuously`);
+            }
+            console.error(`[wechat] poll error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${err.message}`);
+            if (disconnected) {
+              const host = new URL(this.baseUrl).hostname;
+              while (this.running && !await isNetworkUp(host)) {
+                await sleep2(DISCONNECTED_POLL_INTERVAL);
+              }
+              console.log(`[wechat] DNS probe passed for ${host}, retrying poll...`);
+            } else {
+              await sleep2(consecutiveFailures >= MAX_CONSECUTIVE_FAILURES ? BACKOFF_DELAY_MS : RETRY_DELAY_MS);
+              if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) consecutiveFailures = 0;
+            }
+          }
+        }
+      }
+      async processMessage(message) {
+        const senderId = String(message.from_user_id || "").trim();
+        if (!senderId || senderId === this.config.accountId) return;
+        const messageId = String(message.message_id || "").trim();
+        if (messageId && this.dedup.isDuplicate(messageId)) return;
+        const itemList = message.item_list || [];
+        const text = extractText(itemList);
+        if (text) {
+          const contentKey = `content:${senderId}:${crypto.createHash("md5").update(text).digest("hex")}`;
+          if (this.dedup.isDuplicate(contentKey)) return;
+        }
+        const { type: chatType, chatId } = guessChatType(message, this.config.accountId);
+        if (chatType === "group") {
+          if (this.config.groupPolicy === "disabled") return;
+          if (this.config.groupPolicy === "allowlist" && !(this.config.groupAllowFrom || []).includes(chatId)) return;
+        } else {
+          if (!this.isDmAllowed(senderId)) return;
+        }
+        const contextToken = String(message.context_token || "").trim();
+        if (contextToken) this.tokenStore.set(senderId, contextToken);
+        const attachments = [];
+        for (const item of itemList) {
+          const media = await this.downloadMediaItem(item).catch((err) => {
+            console.warn(`[wechat] media download failed: ${err.message}`);
+            return null;
+          });
+          if (media) attachments.push(media);
+        }
+        if (!text && attachments.length === 0) return;
+        console.log(`[wechat] inbound from=${safeId(senderId)} type=${chatType} media=${attachments.length}`);
+        this.messageHandler?.({
+          content: text,
+          from: senderId,
+          fromName: senderId,
+          channel_id: chatId,
+          channel: "wechat",
+          channelType: chatType,
+          isBot: false,
+          messageId: messageId || void 0,
+          recvAt: Date.now(),
+          attachments: attachments.length > 0 ? attachments : void 0
+        });
+      }
+      isDmAllowed(senderId) {
+        if (this.config.dmPolicy === "disabled") return false;
+        if (this.config.dmPolicy === "allowlist") return (this.config.allowFrom || []).includes(senderId);
+        return true;
+      }
+      async downloadMediaItem(item) {
+        const itemType = item.type;
+        let mediaRef = {};
+        let filename = "media.bin";
+        let contentType = "application/octet-stream";
+        let timeoutSec = 60;
+        if (itemType === ITEM_IMAGE) {
+          mediaRef = (item.image_item || {}).media || {};
+          filename = "image.jpg";
+          contentType = "image/jpeg";
+          timeoutSec = 30;
+        } else if (itemType === ITEM_VIDEO) {
+          mediaRef = (item.video_item || {}).media || {};
+          filename = "video.mp4";
+          contentType = "video/mp4";
+          timeoutSec = 120;
+        } else if (itemType === ITEM_FILE) {
+          const fileItem = item.file_item || {};
+          mediaRef = fileItem.media || {};
+          filename = String(fileItem.file_name || "document.bin");
+          contentType = mimeFromFilename(filename);
+          timeoutSec = 60;
+        } else if (itemType === ITEM_VOICE) {
+          mediaRef = (item.voice_item || {}).media || {};
+          if ((item.voice_item || {}).text) return null;
+          filename = "voice.silk";
+          contentType = "audio/silk";
+          timeoutSec = 60;
+        } else {
+          return null;
+        }
+        const data = await downloadAndDecryptMedia(
+          this.cdnBaseUrl,
+          mediaRef.encrypt_query_param,
+          mediaRef.aes_key,
+          mediaRef.full_url,
+          timeoutSec
+        );
+        const tmpDir = path.join(os.tmpdir(), "weixin-media");
+        if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
+        const tmpPath = path.join(tmpDir, `${crypto.randomUUID().replace(/-/g, "")}-${filename}`);
+        fs.writeFileSync(tmpPath, data);
+        return { url: `file://${tmpPath}`, filename, contentType, size: data.length };
+      }
+      // --- Internal: send helpers ---
+      async sendTextChunk(target, text, contextToken) {
+        let lastError = null;
+        let retriedWithoutToken = false;
+        let currentToken = contextToken;
+        for (let attempt = 0; attempt <= SEND_CHUNK_RETRIES; attempt++) {
+          try {
+            const clientId = `engine-weixin-${crypto.randomUUID().replace(/-/g, "")}`;
+            const resp = await apiPost(this.baseUrl, EP_SEND_MESSAGE, {
+              msg: {
+                from_user_id: "",
+                to_user_id: target,
+                client_id: clientId,
+                message_type: MSG_TYPE_BOT,
+                message_state: MSG_STATE_FINISH,
+                item_list: [{ type: ITEM_TEXT, text_item: { text } }],
+                ...currentToken ? { context_token: currentToken } : {}
+              }
+            }, this.config.token, API_TIMEOUT_MS);
+            const ret = resp.ret ?? 0;
+            const errcode = resp.errcode ?? 0;
+            if (ret !== 0 || errcode !== 0) {
+              if (isSessionExpired(ret, errcode, resp.errmsg) && !retriedWithoutToken && currentToken) {
+                retriedWithoutToken = true;
+                currentToken = void 0;
+                this.tokenStore.delete(target);
+                console.warn(`[wechat] session expired for ${safeId(target)}; retrying without context_token`);
+                continue;
+              }
+              if (ret === RATE_LIMIT_ERRCODE || errcode === RATE_LIMIT_ERRCODE) {
+                lastError = new Error(`iLink rate limited: ret=${ret} errcode=${errcode}`);
+                if (attempt >= SEND_CHUNK_RETRIES) break;
+                await sleep2(5e3);
+                continue;
+              }
+              throw new Error(`iLink sendmessage error: ret=${ret} errcode=${errcode} errmsg=${resp.errmsg || ""}`);
+            }
+            return;
+          } catch (err) {
+            lastError = err;
+            if (attempt >= SEND_CHUNK_RETRIES) break;
+            await sleep2(SEND_CHUNK_RETRY_DELAY_MS * (attempt + 1));
+          }
+        }
+        throw lastError;
+      }
+      guessMediaType(filePath, mimeType) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mime = mimeType || mimeFromFilename(filePath);
+        if (mime.startsWith("image/")) return MEDIA_IMAGE;
+        if (mime.startsWith("video/")) return MEDIA_VIDEO;
+        if (ext === ".silk") return MEDIA_VOICE;
+        return MEDIA_FILE;
+      }
+      buildMediaItem(mediaType, params) {
+        const media = {
+          encrypt_query_param: params.encryptedQueryParam,
+          aes_key: params.aesKeyForApi,
+          encrypt_type: 1
+        };
+        if (mediaType === MEDIA_IMAGE) {
+          return { type: ITEM_IMAGE, image_item: { media, mid_size: params.ciphertextSize } };
+        }
+        if (mediaType === MEDIA_VIDEO) {
+          return { type: ITEM_VIDEO, video_item: { media, video_size: params.ciphertextSize, video_md5: params.rawfilemd5 } };
+        }
+        if (mediaType === MEDIA_VOICE) {
+          const voiceItem = { media, encode_type: 6, sample_rate: 24e3, bits_per_sample: 16 };
+          if (typeof params.voiceDurationSec === "number" && params.voiceDurationSec > 0) {
+            voiceItem.playtime = Math.round(params.voiceDurationSec * 1e3);
+          }
+          return { type: ITEM_VOICE, voice_item: voiceItem };
+        }
+        return { type: ITEM_FILE, file_item: { media, file_name: params.filename, len: String(params.plaintextSize) } };
+      }
+      formatMessage(content) {
+        return formatForWechat(content);
+      }
+      splitText(text) {
+        return splitText(text, MAX_MESSAGE_LENGTH);
+      }
+    };
+    EP_GET_BOT_QR = "ilink/bot/get_bot_qrcode";
+    EP_GET_QR_STATUS = "ilink/bot/get_qrcode_status";
+    QR_TIMEOUT_MS = 15e3;
+  }
+});
+
 // src/cli-travel.ts
 var cli_travel_exports = {};
 __export(cli_travel_exports, {
@@ -743,127 +1688,8 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-// src/channels/wechat.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-function sleep2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var ILINK_BASE_URL = "https://ilinkai.weixin.qq.com";
-var ILINK_APP_CLIENT_VERSION = 2 << 16 | 2 << 8 | 0;
-var EP_GET_BOT_QR = "ilink/bot/get_bot_qrcode";
-var EP_GET_QR_STATUS = "ilink/bot/get_qrcode_status";
-var QR_TIMEOUT_MS = 15e3;
-async function wechatQrLogin(options) {
-  const botType = options?.botType || "3";
-  const timeoutSeconds = options?.timeoutSeconds || 480;
-  const stateDir = options?.stateDir || path.join(os.homedir?.() || "/tmp", ".engine7");
-  console.log("[wechat] Fetching QR code from iLink...");
-  let qrResp;
-  try {
-    qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
-  } catch (err) {
-    console.error(`[wechat] Failed to fetch QR code: ${err.message}`);
-    return null;
-  }
-  const qrcodeValue = String(qrResp?.qrcode || "");
-  const qrcodeUrl = String(qrResp?.qrcode_img_content || "");
-  if (!qrcodeValue) {
-    console.error("[wechat] QR response missing qrcode field");
-    return null;
-  }
-  const qrScanData = qrcodeUrl || qrcodeValue;
-  console.log("\n========== \u5FAE\u4FE1\u626B\u7801\u767B\u5F55 ==========");
-  if (qrcodeUrl) {
-    console.log(`\u626B\u7801\u94FE\u63A5: ${qrcodeUrl}`);
-  }
-  console.log("\u8BF7\u7528\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801\uFF08\u6216\u6253\u5F00\u4E0A\u9762\u7684\u94FE\u63A5\uFF09:");
-  console.log("===================================\n");
-  const deadline = Date.now() + timeoutSeconds * 1e3;
-  let currentBaseUrl = ILINK_BASE_URL;
-  let refreshCount = 0;
-  while (Date.now() < deadline) {
-    let statusResp;
-    try {
-      statusResp = await apiGet(currentBaseUrl, `${EP_GET_QR_STATUS}?qrcode=${qrcodeValue}`, "", QR_TIMEOUT_MS);
-    } catch {
-      await sleep2(1e3);
-      continue;
-    }
-    const status = String(statusResp?.status || "wait");
-    if (status === "wait") {
-      process.stdout.write(".");
-    } else if (status === "scaned") {
-      console.log("\n\u5DF2\u626B\u7801\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u91CC\u786E\u8BA4...");
-    } else if (status === "scaned_but_redirect") {
-      const redirectHost = String(statusResp?.redirect_host || "");
-      if (redirectHost) currentBaseUrl = `https://${redirectHost}`;
-    } else if (status === "expired") {
-      refreshCount++;
-      if (refreshCount > 3) {
-        console.log("\n\u4E8C\u7EF4\u7801\u591A\u6B21\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u767B\u5F55\u3002");
-        return null;
-      }
-      console.log(`
-\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u5237\u65B0\u4E2D... (${refreshCount}/3)`);
-      try {
-        qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
-        const newQrValue = String(qrResp?.qrcode || "");
-        const newQrUrl = String(qrResp?.qrcode_img_content || "");
-        if (newQrUrl) console.log(`\u65B0\u626B\u7801\u94FE\u63A5: ${newQrUrl}`);
-      } catch (err) {
-        console.error(`[wechat] QR refresh failed: ${err.message}`);
-        return null;
-      }
-    } else if (status === "confirmed") {
-      const accountId = String(statusResp?.ilink_bot_id || "");
-      const token = String(statusResp?.bot_token || "");
-      const baseUrl = String(statusResp?.baseurl || ILINK_BASE_URL);
-      const userId = String(statusResp?.ilink_user_id || "");
-      if (!accountId || !token) {
-        console.error("[wechat] QR confirmed but credential payload incomplete");
-        return null;
-      }
-      if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
-      const credFile = path.join(stateDir, `weixin-${accountId}.json`);
-      fs.writeFileSync(credFile, JSON.stringify({ accountId, token, baseUrl, userId }, null, 2), "utf8");
-      console.log(`
-\u2705 \u5FAE\u4FE1\u767B\u5F55\u6210\u529F!`);
-      console.log(`   accountId: ${accountId}`);
-      console.log(`   \u51ED\u8BC1\u5DF2\u4FDD\u5B58: ${credFile}`);
-      console.log(`
-\u8BF7\u5C06\u4EE5\u4E0B\u914D\u7F6E\u6DFB\u52A0\u5230 xiaoke.json:`);
-      console.log(JSON.stringify({
-        wechat: {
-          token,
-          accountId,
-          baseUrl: baseUrl !== ILINK_BASE_URL ? baseUrl : void 0
-        }
-      }, null, 2));
-      return { accountId, token, baseUrl, userId };
-    }
-    await sleep2(1e3);
-  }
-  console.log("\n[wechat] QR login timed out");
-  return null;
-}
-async function apiGet(baseUrl, endpoint, _token, timeoutMs) {
-  const url = `${baseUrl.replace(/\/$/, "")}/${endpoint.replace(/^\//, "")}`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const resp = await fetch(url, {
-      method: "GET",
-      signal: controller.signal,
-      headers: { "Accept": "application/json" }
-    });
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
-    return await resp.json();
-  } finally {
-    clearTimeout(timer);
-  }
-}
+// src/cli-init.ts
+init_wechat();
 
 // src/qr-render.ts
 import { createRequire } from "node:module";
@@ -920,6 +1746,7 @@ Engine 7 \u2014 Self-hosted AI agent engine
 
 \u7528\u6CD5:
   engine7 init --state-dir <path> [\u9009\u9879]   \u521D\u59CB\u5316 agent \u5DE5\u4F5C\u76EE\u5F55
+  engine7 addchannel wechat [\u9009\u9879]         \u7ED9\u5DF2\u88C5\u7684 agent \u52A0\u901A\u9053\uFF08\u626B\u7801\uFF0C\u4E0D\u91CD\u8DD1 init\uFF09
   engine7 start [--config <path>]          \u542F\u52A8 Engine
   engine7 restart [--config <path>]        \u91CD\u542F Engine\uFF08\u6740\u65E7\u8FDB\u7A0B+\u542F\u52A8\uFF09
   engine7 service install|uninstall|status \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
@@ -1445,6 +2272,68 @@ async function main() {
     printHelp();
     process.exit(0);
   }
+  if (subcommand === "addchannel") {
+    const channel = args[1] || "";
+    let stateDir = "";
+    let configName = "";
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--state-dir" && args[i + 1]) stateDir = args[++i];
+      else if (args[i] === "--config" && args[i + 1]) configName = args[++i];
+    }
+    if (!stateDir) stateDir = path3.resolve(process.cwd());
+    if (channel === "wechat") {
+      console.log("\u{1F4F1} \u5FAE\u4FE1\u626B\u7801\u63A5\u5165\uFF08iLink \u4E2A\u4EBA\u5FAE\u4FE1\uFF0C1v1 \u79C1\u804A\uFF09");
+      console.log("   \u63D0\u793A\uFF1A\u4E00\u4E2A\u5FAE\u4FE1\u53F7\u53EA\u80FD\u7ED1\u4E00\u4E2A bot\uFF1Bbot \u4E0D\u8FDB\u7FA4\uFF08\u817E\u8BAF\u9650\u5236\uFF09\n");
+      const { wechatQrLogin: wechatQrLogin2 } = await Promise.resolve().then(() => (init_wechat(), wechat_exports));
+      const cred = await wechatQrLogin2({ timeoutSeconds: 300, stateDir });
+      if (!cred) {
+        console.error("\u274C \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25\uFF0C\u672A\u4FEE\u6539\u4EFB\u4F55\u914D\u7F6E");
+        process.exit(1);
+      }
+      const configsDir = path3.join(stateDir, "configs");
+      let configFile = "";
+      if (configName) {
+        configFile = path3.join(configsDir, configName);
+      } else if (fs3.existsSync(configsDir)) {
+        const candidates = fs3.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+        for (const f of candidates) {
+          const full = path3.join(configsDir, f);
+          try {
+            const j2 = JSON.parse(fs3.readFileSync(full, "utf8"));
+            if (j2.channels) {
+              configFile = full;
+              break;
+            }
+          } catch {
+          }
+        }
+        if (!configFile && candidates.length) configFile = path3.join(configsDir, candidates[0]);
+      }
+      if (!configFile || !fs3.existsSync(configFile)) {
+        console.log("\n\u26A0\uFE0F \u6CA1\u627E\u5230 config \u6587\u4EF6\uFF0C\u8BF7\u624B\u52A8\u628A\u4EE5\u4E0B\u6BB5\u52A0\u8FDB\u4F60\u7684 config \u7684 channels \u91CC\uFF1A");
+        console.log(JSON.stringify({ wechat: { enabled: true, token: cred.token, accountId: cred.accountId, dmPolicy: "pairing", group: { policy: "disabled" } } }, null, 2));
+        process.exit(0);
+      }
+      const j = JSON.parse(fs3.readFileSync(configFile, "utf8"));
+      j.channels = j.channels || {};
+      j.channels.wechat = {
+        enabled: true,
+        token: cred.token,
+        accountId: cred.accountId,
+        dmPolicy: "pairing",
+        group: { policy: "disabled" }
+      };
+      fs3.writeFileSync(configFile, JSON.stringify(j, null, 2), "utf8");
+      console.log(`
+\u2705 \u5FAE\u4FE1\u901A\u9053\u5DF2\u5199\u5165: ${configFile}`);
+      console.log(`   accountId: ${cred.accountId}`);
+      console.log("\n\u91CD\u542F engine \u751F\u6548: engine7 restart");
+      process.exit(0);
+    }
+    console.error(`\u672A\u77E5\u901A\u9053: ${channel || "(\u7A7A)"}\u3002\u76EE\u524D\u652F\u6301: wechat`);
+    console.error("\u7528\u6CD5: engine7 addchannel wechat [--state-dir <path>] [--config <file>]");
+    process.exit(1);
+  }
   if (subcommand === "export") {
     const { doExport: doExport2 } = await Promise.resolve().then(() => (init_cli_travel(), cli_travel_exports));
     let exportStateDir = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engine7",
-  "version": "7.1.41",
+  "version": "7.1.42",
   "type": "module",
   "description": "Engine 7 — 给助手一个家 / A home for your AI assistant",
   "main": "dist/main.mjs",