engine7 7.1.40 → 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, {
@@ -22,20 +967,20 @@ __export(cli_travel_exports, {
   loadTravelConfig: () => loadTravelConfig,
   saveTravelConfig: () => saveTravelConfig
 });
-import * as path from "node:path";
-import * as fs from "node:fs";
-import * as os from "node:os";
+import * as path2 from "node:path";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
 import { execSync } from "node:child_process";
 function loadTravelConfig() {
   try {
-    if (!fs.existsSync(CONFIG_PATH)) return null;
-    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!fs2.existsSync(CONFIG_PATH)) return null;
+    return JSON.parse(fs2.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveTravelConfig(cfg) {
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+  fs2.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
 }
 function sanitizeContent(content, dirs) {
   let result = content;
@@ -60,7 +1005,7 @@ function restoreContent(content, dirs) {
   return result;
 }
 function isTextFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
+  const ext = path2.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(ext);
 }
 function shouldExclude(name) {
@@ -75,14 +1020,14 @@ function shouldExclude(name) {
 }
 function collectFiles(rootDir, includeSet, optionalSet) {
   const files = [];
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(rootDir, { withFileTypes: true });
   for (const entry of entries) {
     if (shouldExclude(entry.name)) continue;
-    const fullPath = path.join(rootDir, entry.name);
-    const realPath = fs.realpathSync(fullPath);
+    const fullPath = path2.join(rootDir, entry.name);
+    const realPath = fs2.realpathSync(fullPath);
     if (realPath !== fullPath) {
       try {
-        const lstat = fs.lstatSync(fullPath);
+        const lstat = fs2.lstatSync(fullPath);
         if (lstat.isSymbolicLink()) {
           continue;
         }
@@ -103,12 +1048,12 @@ function collectFiles(rootDir, includeSet, optionalSet) {
 function collectAllFiles(dir) {
   const files = [];
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (shouldExclude(entry.name)) continue;
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       try {
-        if (fs.lstatSync(fullPath).isSymbolicLink()) continue;
+        if (fs2.lstatSync(fullPath).isSymbolicLink()) continue;
       } catch {
       }
       if (entry.isDirectory()) {
@@ -123,30 +1068,30 @@ function collectAllFiles(dir) {
 }
 function readMainEngineUuid(agentsDir) {
   try {
-    const platformMapPath = path.join(agentsDir, "main", "sessions", "platform-map.json");
-    const indexMapPath = path.join(agentsDir, "main", "sessions", "session-index.json");
-    if (!fs.existsSync(platformMapPath) || !fs.existsSync(indexMapPath)) return null;
-    const platformMap = JSON.parse(fs.readFileSync(platformMapPath, "utf-8"));
+    const platformMapPath = path2.join(agentsDir, "main", "sessions", "platform-map.json");
+    const indexMapPath = path2.join(agentsDir, "main", "sessions", "session-index.json");
+    if (!fs2.existsSync(platformMapPath) || !fs2.existsSync(indexMapPath)) return null;
+    const platformMap = JSON.parse(fs2.readFileSync(platformMapPath, "utf-8"));
     const mainPlatformId = platformMap["scope:main"] || platformMap["main"];
     if (!mainPlatformId) return null;
-    const indexMap = JSON.parse(fs.readFileSync(indexMapPath, "utf-8"));
+    const indexMap = JSON.parse(fs2.readFileSync(indexMapPath, "utf-8"));
     const entry = indexMap[mainPlatformId];
     if (!entry || !entry.file) return null;
-    const basename3 = path.basename(entry.file).replace(/\.jsonl$/, "");
-    return basename3;
+    const basename4 = path2.basename(entry.file).replace(/\.jsonl$/, "");
+    return basename4;
   } catch {
     return null;
   }
 }
 function collectRecentSessions(agentsDir, _days = 7) {
   const files = [];
-  if (!fs.existsSync(agentsDir)) return files;
+  if (!fs2.existsSync(agentsDir)) return files;
   const sessionGroups = /* @__PURE__ */ new Map();
   function scanSessionsDir(dir) {
     try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
+        const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
           scanSessionsDir(fullPath);
           continue;
@@ -170,7 +1115,7 @@ function collectRecentSessions(agentsDir, _days = 7) {
         if (entry.name.endsWith(".jsonl")) {
           group.jsonl = fullPath;
         } else {
-          const stat = fs.statSync(fullPath);
+          const stat = fs2.statSync(fullPath);
           group.archived.push({ file: fullPath, mtime: stat.mtimeMs });
         }
       }
@@ -189,37 +1134,37 @@ function collectRecentSessions(agentsDir, _days = 7) {
 }
 async function doExport(opts) {
   const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
-  const workspace = (opts.workspace || path.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
-  const engineHome = path.join(os.homedir(), ".engine7").replace(/[/\\]+$/, "");
+  const workspace = (opts.workspace || path2.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
+  const engineHome = path2.join(os2.homedir(), ".engine7").replace(/[/\\]+$/, "");
   console.log(`\u{1F4E6} engine7 export`);
   console.log(`   agent: ${agentName}`);
   console.log(`   state: ${stateDir}`);
   console.log(`   workspace: ${workspace}`);
-  if (!fs.existsSync(workspace)) {
+  if (!fs2.existsSync(workspace)) {
     console.error(`\u274C workspace \u4E0D\u5B58\u5728: ${workspace}`);
     process.exit(1);
   }
   const dirs = { workspace, stateDir, engineHome };
   const wsFiles = collectFiles(workspace, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL);
-  const sessionFiles = collectRecentSessions(path.join(stateDir, "agents"), 7);
-  const configsDir = path.join(stateDir, "configs");
+  const sessionFiles = collectRecentSessions(path2.join(stateDir, "agents"), 7);
+  const configsDir = path2.join(stateDir, "configs");
   const configFiles = [];
-  if (fs.existsSync(configsDir)) {
+  if (fs2.existsSync(configsDir)) {
     for (const f of collectAllFiles(configsDir)) {
-      if (shouldExclude(path.basename(f))) continue;
+      if (shouldExclude(path2.basename(f))) continue;
       configFiles.push(f);
     }
   }
   const EVEROS_SKIP = /* @__PURE__ */ new Set([".tmp", ".lock", "import.log", "import_progress.json"]);
-  const everosDir = path.join(stateDir, ".everos");
+  const everosDir = path2.join(stateDir, ".everos");
   const everosFiles = [];
-  if (fs.existsSync(everosDir)) {
+  if (fs2.existsSync(everosDir)) {
     for (const f of collectAllFiles(everosDir)) {
-      if (EVEROS_SKIP.has(path.basename(f))) continue;
+      if (EVEROS_SKIP.has(path2.basename(f))) continue;
       everosFiles.push(f);
     }
-    const walFile = path.join(everosDir, ".index", "sqlite", "system.db-wal");
-    if (fs.existsSync(walFile) && fs.statSync(walFile).size > 0) {
+    const walFile = path2.join(everosDir, ".index", "sqlite", "system.db-wal");
+    if (fs2.existsSync(walFile) && fs2.statSync(walFile).size > 0) {
       console.warn(`\u26A0\uFE0F  .everos/system.db-wal \u975E\u7A7A\u2014\u2014everos \u670D\u52A1\u53EF\u80FD\u6B63\u5728\u5199\u5165\uFF0C\u5FEB\u7167\u53EF\u80FD\u4E0D\u4E00\u81F4`);
       console.warn(`   \u5EFA\u8BAE: \u5148\u505C everos \u670D\u52A1\u518D export\uFF0C\u6216 import \u540E\u91CD\u5EFA\u7D22\u5F15`);
     }
@@ -227,16 +1172,16 @@ async function doExport(opts) {
   console.log(`   workspace \u6587\u4EF6: ${wsFiles.length}`);
   console.log(`   session jsonl: ${sessionFiles.length} (\u6700\u8FD17\u5929)`);
   console.log(`   configs: ${configFiles.length}`);
-  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs2.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
   if (dryRun2) {
     console.log(`
 [DRY RUN] \u4F1A\u6253\u5305\u4EE5\u4E0B\u6587\u4EF6:`);
-    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path.relative(workspace, f)}`));
+    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path2.relative(workspace, f)}`));
     if (wsFiles.length > 20) console.log(`   ... \u8FD8\u6709 ${wsFiles.length - 20} \u4E2A\u6587\u4EF6`);
     if (everosFiles.length > 0) {
       console.log(`
 [DRY RUN] everos (${everosFiles.length} \u6587\u4EF6):`);
-      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path.relative(stateDir, f)}`));
+      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path2.relative(stateDir, f)}`));
       if (everosFiles.length > 10) console.log(`   ... \u8FD8\u6709 ${everosFiles.length - 10} \u4E2A\u6587\u4EF6`);
     }
     console.log(`
@@ -245,46 +1190,46 @@ async function doExport(opts) {
   }
   const now = /* @__PURE__ */ new Date();
   const version = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
-  const tmpDir = path.join(os.tmpdir(), `engine7-export-${agentName}-${version}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const stagingDir = path.join(tmpDir, agentName);
-  fs.mkdirSync(stagingDir, { recursive: true });
+  const tmpDir = path2.join(os2.tmpdir(), `engine7-export-${agentName}-${version}`);
+  fs2.mkdirSync(tmpDir, { recursive: true });
+  const stagingDir = path2.join(tmpDir, agentName);
+  fs2.mkdirSync(stagingDir, { recursive: true });
   let fileCount = 0;
   let totalSize = 0;
   let copyFail = 0;
   const copyOne = (srcFile, relRoot, destRoot) => {
-    const relPath = path.relative(relRoot, srcFile);
-    const destFile = path.join(destRoot, relPath);
-    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const relPath = path2.relative(relRoot, srcFile);
+    const destFile = path2.join(destRoot, relPath);
+    fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
     try {
       if (isTextFile(srcFile)) {
-        const content = fs.readFileSync(srcFile, "utf-8");
-        fs.writeFileSync(destFile, sanitizeContent(content, dirs));
+        const content = fs2.readFileSync(srcFile, "utf-8");
+        fs2.writeFileSync(destFile, sanitizeContent(content, dirs));
       } else {
-        fs.copyFileSync(srcFile, destFile);
+        fs2.copyFileSync(srcFile, destFile);
       }
       fileCount++;
-      totalSize += fs.statSync(srcFile).size;
+      totalSize += fs2.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
     }
   };
-  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path.join(stagingDir, "workspace"));
+  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path2.join(stagingDir, "workspace"));
   for (const srcFile of sessionFiles) {
-    const relPath = path.relative(stateDir, srcFile);
-    const destFile = path.join(stagingDir, relPath);
-    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const relPath = path2.relative(stateDir, srcFile);
+    const destFile = path2.join(stagingDir, relPath);
+    fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
     try {
-      let content = fs.readFileSync(srcFile, "utf-8");
+      let content = fs2.readFileSync(srcFile, "utf-8");
       content = sanitizeContent(content, dirs);
-      const baseName = path.basename(srcFile);
+      const baseName = path2.basename(srcFile);
       if (baseName === "session-index.json" || baseName === "platform-map.json") {
         content = content.split("\\\\").join("/");
       }
-      fs.writeFileSync(destFile, content);
+      fs2.writeFileSync(destFile, content);
       fileCount++;
-      totalSize += fs.statSync(srcFile).size;
+      totalSize += fs2.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
@@ -306,13 +1251,13 @@ async function doExport(opts) {
     totalSize,
     note
   };
-  fs.writeFileSync(path.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  const archiveFile = path.join(tmpDir, `${agentName}-${version}.tar.gz`);
+  fs2.writeFileSync(path2.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const archiveFile = path2.join(tmpDir, `${agentName}-${version}.tar.gz`);
   console.log(`
 \u{1F5DC}\uFE0F  \u6253\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
   execSync(`"${tarExe}" -czf "${archiveFile}" -C "${tmpDir}" ${agentName}`, { stdio: "pipe" });
-  const archiveSize = fs.statSync(archiveFile).size;
+  const archiveSize = fs2.statSync(archiveFile).size;
   console.log(`\u2705 \u6253\u5305\u5B8C\u6210: ${archiveFile} (${(archiveSize / 1024 / 1024).toFixed(1)} MB, ${fileCount} \u6587\u4EF6${copyFail ? `, \u5931\u8D25 ${copyFail}` : ""})`);
   const cfg = loadTravelConfig();
   if (!cfg || !cfg.githubToken) {
@@ -335,8 +1280,8 @@ async function doImport(opts) {
     console.error(`   \u914D\u7F6E: \u7F16\u8F91 ${CONFIG_PATH}`);
     process.exit(1);
   }
-  const tmpDir = path.join(os.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = path2.join(os2.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
+  fs2.mkdirSync(tmpDir, { recursive: true });
   const archiveFile = await downloadFromGitHub(cfg, agentName, version, tmpDir);
   console.log(`\u2705 \u4E0B\u8F7D\u5B8C\u6210: ${archiveFile}`);
   if (dryRun2) {
@@ -347,99 +1292,99 @@ async function doImport(opts) {
   console.log(`\u{1F4C2} \u89E3\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
   execSync(`"${tarExe}" -xzf "${archiveFile}" -C "${tmpDir}"`, { stdio: "pipe" });
-  const stagingDir = path.join(tmpDir, agentName);
-  const manifestPath = path.join(stagingDir, "manifest.json");
-  if (!fs.existsSync(manifestPath)) {
+  const stagingDir = path2.join(tmpDir, agentName);
+  const manifestPath = path2.join(stagingDir, "manifest.json");
+  if (!fs2.existsSync(manifestPath)) {
     console.error(`\u274C manifest.json \u4E0D\u5B58\u5728\uFF0C\u6587\u4EF6\u53EF\u80FD\u635F\u574F`);
     process.exit(1);
   }
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-  const workspace = path.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
-  const engineHome = path.join(os.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+  const workspace = path2.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const engineHome = path2.join(os2.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
   const dirs = { workspace, stateDir: stateDir.replace(/\\/g, "/").replace(/[/\\]+$/, ""), engineHome };
   console.log(`   \u7248\u672C: ${manifest.version}`);
   console.log(`   \u521B\u5EFA: ${manifest.createdAt}`);
   console.log(`   \u6587\u4EF6\u6570: ${manifest.fileCount}`);
-  const wsStaging = path.join(stagingDir, "workspace");
+  const wsStaging = path2.join(stagingDir, "workspace");
   let restoredCount = 0;
   let skipCount = 0;
-  if (fs.existsSync(wsStaging)) {
+  if (fs2.existsSync(wsStaging)) {
     const allFiles = collectAllFiles(wsStaging);
     for (const srcFile of allFiles) {
-      const relPath = path.relative(wsStaging, srcFile);
-      const destFile = path.join(workspace, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(wsStaging, srcFile);
+      const destFile = path2.join(workspace, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs.readFileSync(srcFile, "utf-8");
-          fs.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs2.readFileSync(srcFile, "utf-8");
+          fs2.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs.copyFileSync(srcFile, destFile);
+          fs2.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path.relative(wsStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path2.relative(wsStaging, srcFile)} (${e.code || e.message})`);
       }
     }
   }
-  const agentsStaging = path.join(stagingDir, "agents");
-  if (fs.existsSync(agentsStaging)) {
+  const agentsStaging = path2.join(stagingDir, "agents");
+  if (fs2.existsSync(agentsStaging)) {
     const sessionFiles = collectAllFiles(agentsStaging);
     for (const srcFile of sessionFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
-      const content = fs.readFileSync(srcFile, "utf-8");
-      fs.writeFileSync(destFile, restoreContent(content, dirs));
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
+      const content = fs2.readFileSync(srcFile, "utf-8");
+      fs2.writeFileSync(destFile, restoreContent(content, dirs));
       restoredCount++;
     }
   }
-  const configsStaging = path.join(stagingDir, "configs");
-  if (fs.existsSync(configsStaging)) {
+  const configsStaging = path2.join(stagingDir, "configs");
+  if (fs2.existsSync(configsStaging)) {
     const cfgFiles = collectAllFiles(configsStaging);
     for (const srcFile of cfgFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       if (isTextFile(srcFile)) {
-        const content = fs.readFileSync(srcFile, "utf-8");
-        fs.writeFileSync(destFile, restoreContent(content, dirs));
+        const content = fs2.readFileSync(srcFile, "utf-8");
+        fs2.writeFileSync(destFile, restoreContent(content, dirs));
       } else {
-        fs.copyFileSync(srcFile, destFile);
+        fs2.copyFileSync(srcFile, destFile);
       }
       restoredCount++;
     }
   }
-  const everosStaging = path.join(stagingDir, ".everos");
-  if (fs.existsSync(everosStaging)) {
+  const everosStaging = path2.join(stagingDir, ".everos");
+  if (fs2.existsSync(everosStaging)) {
     const everosFiles = collectAllFiles(everosStaging);
     for (const srcFile of everosFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs.readFileSync(srcFile, "utf-8");
-          fs.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs2.readFileSync(srcFile, "utf-8");
+          fs2.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs.copyFileSync(srcFile, destFile);
+          fs2.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path.relative(everosStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path2.relative(everosStaging, srcFile)} (${e.code || e.message})`);
       }
     }
     console.log(`   everos: ${everosFiles.length} \u6587\u4EF6\u5DF2\u6062\u590D`);
   }
   console.log(`\u2705 \u6062\u590D\u5B8C\u6210: ${restoredCount} \u6587\u4EF6 \u2192 ${stateDir}${skipCount ? ` (\u8DF3\u8FC7 ${skipCount})` : ""}`);
   const platformConfigName = process.platform === "darwin" ? "xiaoke-mac.json" : "xiaoke-win.json";
-  const restoredConfigPath = path.join(stateDir, "configs", platformConfigName);
-  const configToUse = fs.existsSync(restoredConfigPath) ? restoredConfigPath : path.join(stateDir, "configs", "xiaoke.json");
+  const restoredConfigPath = path2.join(stateDir, "configs", platformConfigName);
+  const configToUse = fs2.existsSync(restoredConfigPath) ? restoredConfigPath : path2.join(stateDir, "configs", "xiaoke.json");
   console.log(`
 \u{1F4A1} \u4E0B\u4E00\u6B65: engine7 start --config "${configToUse}"`);
-  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs2.rmSync(tmpDir, { recursive: true, force: true });
 }
 async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
   const repo = `${cfg.githubOwner}/${cfg.repoName}`;
@@ -469,8 +1414,8 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     }
     const release = await createRes.json();
     const uploadUrl = release.upload_url.replace("{?name,label}", "");
-    const fileBuffer = fs.readFileSync(archiveFile);
-    const fileName = path.basename(archiveFile);
+    const fileBuffer = fs2.readFileSync(archiveFile);
+    const fileName = path2.basename(archiveFile);
     const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
       method: "POST",
       headers: {
@@ -493,7 +1438,7 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     throw e;
   }
   try {
-    fs.rmSync(path.dirname(archiveFile), { recursive: true, force: true });
+    fs2.rmSync(path2.dirname(archiveFile), { recursive: true, force: true });
   } catch {
   }
 }
@@ -525,8 +1470,8 @@ async function downloadFromGitHub(cfg, agentName, version, destDir) {
     throw new Error(`\u4E0B\u8F7D asset \u5931\u8D25: ${downloadRes.status}`);
   }
   const buffer = Buffer.from(await downloadRes.arrayBuffer());
-  const archiveFile = path.join(destDir, asset.name);
-  fs.writeFileSync(archiveFile, buffer);
+  const archiveFile = path2.join(destDir, asset.name);
+  fs2.writeFileSync(archiveFile, buffer);
   return archiveFile;
 }
 async function getLatestReleaseTag(cfg, agentName) {
@@ -551,7 +1496,7 @@ var CONFIG_PATH, PATH_PLACEHOLDERS, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL, WORKS
 var init_cli_travel = __esm({
   "src/cli-travel.ts"() {
     "use strict";
-    CONFIG_PATH = path.join(os.homedir(), ".engine7-travel.json");
+    CONFIG_PATH = path2.join(os2.homedir(), ".engine7-travel.json");
     PATH_PLACEHOLDERS = [
       { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
       { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
@@ -624,8 +1569,8 @@ var init_cli_travel = __esm({
 });
 
 // src/cli-init.ts
-import * as path2 from "node:path";
-import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import * as fs3 from "node:fs";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 
@@ -743,6 +1688,9 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/cli-init.ts
+init_wechat();
+
 // src/qr-render.ts
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
@@ -761,7 +1709,7 @@ async function renderQrTerminal(url, options) {
 
 // src/cli-init.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
+var __dirname = path3.dirname(__filename);
 var SCHEMA_VERSION = 1;
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -786,10 +1734,10 @@ function parseArgs() {
     }
   }
   if (!stateDir) {
-    stateDir = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    stateDir = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     console.log(`   \u4F7F\u7528\u9ED8\u8BA4\u76EE\u5F55: ${stateDir}`);
   }
-  stateDir = path2.resolve(stateDir);
+  stateDir = path3.resolve(stateDir);
   return { stateDir, quick, dryRun: dryRun2, force };
 }
 function printHelp() {
@@ -798,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
@@ -860,6 +1809,7 @@ function getDefaultValues(stateDir) {
     stateDir,
     agentName: "Agent",
     primaryProvider: "dashscope",
+    zhipuPlan: "",
     primaryApiKey: "",
     primaryModel: "dashscope/qwen3.7-max",
     visionModel: "dashscope/qwen3.7-max",
@@ -870,6 +1820,9 @@ function getDefaultValues(stateDir) {
     feishuAppId: "",
     feishuAppSecret: "",
     feishuOpenId: "",
+    wechatEnabled: false,
+    wechatToken: "",
+    wechatAccountId: "",
     tavilyKey: "",
     apiPort: 16990
   };
@@ -887,6 +1840,12 @@ async function interactiveConfig(rl, defaults) {
   };
   const chosenProvider = await askChoice(rl, "\u4E3B\u6A21\u578B Provider:", providers, 0);
   v.primaryProvider = providerMap[chosenProvider] || "dashscope";
+  v.zhipuPlan = "";
+  if (v.primaryProvider === "zhipu") {
+    const planOptions = ["coding-plan (GLM Coding \u8BA2\u9605)", "token-plan (\u666E\u901A\u6309\u91CF/TokenPlan)"];
+    const chosenPlan = await askChoice(rl, "\u667A\u8C31\u8BA2\u9605\u7C7B\u578B:", planOptions, 0);
+    v.zhipuPlan = chosenPlan.startsWith("coding") ? "coding" : "token";
+  }
   const keyMap = {
     dashscope: "DashScope API Key",
     minimax: "MiniMax API Key",
@@ -974,6 +1933,44 @@ async function interactiveConfig(rl, defaults) {
       v.feishuOpenId = await ask(rl, "\u4F60\u7684\u98DE\u4E66 open_id\uFF08\u56DE\u8F66\u8DF3\u8FC7\uFF09", "");
     }
   }
+  const wechatAns = await ask(rl, "\u542F\u7528\u5FAE\u4FE1? (y/n)", "n");
+  v.wechatEnabled = wechatAns.toLowerCase() === "y";
+  if (v.wechatEnabled) {
+    console.log("\n  \u5FAE\u4FE1\u63A5\u5165\u65B9\u5F0F\uFF1A");
+    console.log("  1. \u626B\u7801\u7ED1\u5B9A\uFF08\u63A8\u8350\uFF0C\u7528\u4F60\u81EA\u5DF1\u7684\u5FAE\u4FE1\u626B\u4E00\u4E0B\u5C31\u884C\uFF09");
+    console.log("  2. \u624B\u52A8\u8F93\u5165 token\uFF08\u5DF2\u6709\u51ED\u8BC1\u65F6\uFF09");
+    const wechatMode = await ask(rl, "\u9009\u62E9 (1/2)", "1");
+    if (wechatMode === "1") {
+      console.log("\n\u{1F4DD} \u6B63\u5728\u751F\u6210\u5FAE\u4FE1\u4E8C\u7EF4\u7801...\n");
+      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\uFF0C\u79C1\u804A 1v1");
+      const cred = await wechatQrLogin({ timeoutSeconds: 300, stateDir: v.stateDir });
+      if (cred) {
+        v.wechatToken = cred.token;
+        v.wechatAccountId = cred.accountId;
+        console.log(`
+  \u2705 accountId: ${cred.accountId}`);
+        console.log(`  \u2705 \u51ED\u8BC1\u5DF2\u81EA\u52A8\u4FDD\u5B58\uFF0Cconfig \u5C06\u81EA\u52A8\u5199\u5165`);
+      } else {
+        console.log("\n  \u26A0\uFE0F \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25");
+        const retry = await ask(rl, "\u91CD\u8BD5\u626B\u7801? (y/n)", "y");
+        if (retry.toLowerCase() === "y") {
+          const cred2 = await wechatQrLogin({ timeoutSeconds: 300, stateDir: v.stateDir });
+          if (cred2) {
+            v.wechatToken = cred2.token;
+            v.wechatAccountId = cred2.accountId;
+          } else {
+            console.log("\n  \u26A0\uFE0F \u518D\u6B21\u5931\u8D25\uFF0C\u8DF3\u8FC7\u5FAE\u4FE1\uFF08\u4E4B\u540E\u53EF\u624B\u52A8\u914D\u7F6E\uFF09");
+            v.wechatEnabled = false;
+          }
+        } else {
+          v.wechatEnabled = false;
+        }
+      }
+    } else {
+      v.wechatToken = await ask(rl, "\u5FAE\u4FE1 token");
+      v.wechatAccountId = await ask(rl, "\u5FAE\u4FE1 accountId");
+    }
+  }
   const tavilyKey = await ask(rl, "Tavily API Key\uFF08\u8054\u7F51\u641C\u7D22\uFF0C\u56DE\u8F66\u8DF3\u8FC7\uFF09", "");
   v.tavilyKey = tavilyKey;
   const portAns = await ask(rl, "API \u7AEF\u53E3", String(defaults.apiPort));
@@ -981,7 +1978,7 @@ async function interactiveConfig(rl, defaults) {
   return v;
 }
 function generateConfig(v) {
-  const workspace = path2.join(v.stateDir, "workspace").replace(/\\/g, "/");
+  const workspace = path3.join(v.stateDir, "workspace").replace(/\\/g, "/");
   const config = {
     schemaVersion: SCHEMA_VERSION,
     stateDir: v.stateDir.replace(/\\/g, "/"),
@@ -1041,7 +2038,16 @@ function generateConfig(v) {
         connectionMode: "websocket",
         dmPolicy: "pairing",
         groupPolicy: "open"
-      }
+      },
+      ...v.wechatEnabled && v.wechatToken ? {
+        wechat: {
+          enabled: true,
+          token: v.wechatToken,
+          accountId: v.wechatAccountId,
+          dmPolicy: "pairing",
+          group: { policy: "disabled" }
+        }
+      } : {}
     },
     api: { port: v.apiPort },
     prompt: {
@@ -1080,7 +2086,7 @@ function generateConfig(v) {
       ]
     },
     zhipu: {
-      baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4 ",
+      baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4",
       api: "openai-completions",
       models: [
         { id: "glm-5.1", name: "GLM-5.1", reasoning: true, input: ["text"], contextWindow: 204800, maxTokens: 131072 },
@@ -1098,8 +2104,12 @@ function generateConfig(v) {
     }
   };
   if (providerDefs[v.primaryProvider]) {
+    const def = { ...providerDefs[v.primaryProvider] };
+    if (v.primaryProvider === "zhipu" && v.zhipuPlan === "token") {
+      def.baseUrl = "https://open.bigmodel.cn/api/paas/v4";
+    }
     config.models.providers[v.primaryProvider] = {
-      ...providerDefs[v.primaryProvider],
+      ...def,
       apiKey: v.primaryApiKey
     };
   }
@@ -1107,45 +2117,45 @@ function generateConfig(v) {
 }
 function buildDirTree(v) {
   const d = v.stateDir;
-  const w = path2.join(d, "workspace");
+  const w = path3.join(d, "workspace");
   const now = (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false });
   return [
     // 目录
-    { path: path2.join(d, "configs"), type: "dir" },
-    { path: path2.join(d, "state", "agents", "main", "sessions"), type: "dir" },
-    { path: path2.join(w, "prompts"), type: "dir" },
-    { path: path2.join(w, "memory", "daily"), type: "dir" },
-    { path: path2.join(w, "docs", "research"), type: "dir" },
-    { path: path2.join(w, "docs", "todo"), type: "dir" },
-    { path: path2.join(w, "docs", "decisions"), type: "dir" },
-    { path: path2.join(w, "docs", "knowledge"), type: "dir" },
-    { path: path2.join(w, "docs", "sop"), type: "dir" },
-    { path: path2.join(d, "logs"), type: "dir" },
-    { path: path2.join(d, "media", "inbound"), type: "dir" },
+    { path: path3.join(d, "configs"), type: "dir" },
+    { path: path3.join(d, "state", "agents", "main", "sessions"), type: "dir" },
+    { path: path3.join(w, "prompts"), type: "dir" },
+    { path: path3.join(w, "memory", "daily"), type: "dir" },
+    { path: path3.join(w, "docs", "research"), type: "dir" },
+    { path: path3.join(w, "docs", "todo"), type: "dir" },
+    { path: path3.join(w, "docs", "decisions"), type: "dir" },
+    { path: path3.join(w, "docs", "knowledge"), type: "dir" },
+    { path: path3.join(w, "docs", "sop"), type: "dir" },
+    { path: path3.join(d, "logs"), type: "dir" },
+    { path: path3.join(d, "media", "inbound"), type: "dir" },
     // workspace 文件
     {
-      path: path2.join(w, "SESSION-STATE.md"),
+      path: path3.join(w, "SESSION-STATE.md"),
       type: "file",
       content: readTemplate("workspace/SESSION-STATE.md").replace("{{CURRENT_TIME}}", now)
     },
-    { path: path2.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
+    { path: path3.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
     {
-      path: path2.join(w, "SOUL.md"),
+      path: path3.join(w, "SOUL.md"),
       type: "file",
       content: readTemplate("workspace/SOUL.md").replace(/\{\{AGENT_NAME\}\}/g, v.agentName)
     },
-    { path: path2.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
+    { path: path3.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
     {
-      path: path2.join(w, "prompts", "contacts.md"),
+      path: path3.join(w, "prompts", "contacts.md"),
       type: "file",
       content: readTemplate("workspace/prompts/contacts.md").replace("{{DISCORD_USER_ID}}", v.discordUserId || "YOUR_DISCORD_ID").replace("{{FEISHU_OPEN_ID}}", v.feishuOpenId || "YOUR_FEISHU_OPEN_ID")
     },
-    { path: path2.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
-    { path: path2.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
-    { path: path2.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
+    { path: path3.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
+    { path: path3.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
+    { path: path3.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
     // package.json — 让 agent 目录成为独立 npm 项目根，防止 npm hoisting
     {
-      path: path2.join(d, "package.json"),
+      path: path3.join(d, "package.json"),
       type: "file",
       content: JSON.stringify({
         name: v.agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-") || "agent",
@@ -1156,7 +2166,7 @@ function buildDirTree(v) {
     },
     // 启动脚本（根据 OS 生成）
     ...process.platform === "win32" ? [{
-      path: path2.join(d, "start.cmd"),
+      path: path3.join(d, "start.cmd"),
       type: "file",
       content: `@echo off
 rem Engine 7 startup script
@@ -1188,7 +2198,7 @@ if %ERRORLEVEL% NEQ 0 (
 )
 `
     }] : [{
-      path: path2.join(d, "start.sh"),
+      path: path3.join(d, "start.sh"),
       type: "file",
       content: `#!/bin/bash
 # Engine 7 startup script
@@ -1221,13 +2231,13 @@ node "$ENGINE7_BIN" --engine-config configs/main7.json
 }
 function readTemplate(relativePath) {
   const candidates = [
-    path2.join(__dirname, "..", "templates", relativePath),
-    path2.join(__dirname, "..", "..", "templates", relativePath),
-    path2.join(process.cwd(), "templates", relativePath)
+    path3.join(__dirname, "..", "templates", relativePath),
+    path3.join(__dirname, "..", "..", "templates", relativePath),
+    path3.join(process.cwd(), "templates", relativePath)
   ];
   for (const p of candidates) {
-    if (fs2.existsSync(p)) {
-      return fs2.readFileSync(p, "utf-8");
+    if (fs3.existsSync(p)) {
+      return fs3.readFileSync(p, "utf-8");
     }
   }
   throw new Error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${relativePath}\uFF08\u627E\u4E86: ${candidates.join(", ")}\uFF09`);
@@ -1242,11 +2252,11 @@ function dryRun(entries) {
 function execute(entries) {
   for (const e of entries) {
     if (e.type === "dir") {
-      fs2.mkdirSync(e.path, { recursive: true });
+      fs3.mkdirSync(e.path, { recursive: true });
       console.log(`  \u{1F4C1} ${e.path}`);
     } else {
-      fs2.mkdirSync(path2.dirname(e.path), { recursive: true });
-      fs2.writeFileSync(e.path, e.content || "", "utf-8");
+      fs3.mkdirSync(path3.dirname(e.path), { recursive: true });
+      fs3.writeFileSync(e.path, e.content || "", "utf-8");
       console.log(`  \u{1F4C4} ${e.path}`);
     }
   }
@@ -1262,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 = "";
@@ -1274,8 +2346,8 @@ async function main() {
       else if (args[i] === "--note" && args[i + 1]) note = args[++i];
       else if (args[i] === "--dry-run") dryRun2 = true;
     }
-    if (!exportStateDir) exportStateDir = path2.resolve(process.cwd());
-    if (!agentName) agentName = path2.basename(exportStateDir);
+    if (!exportStateDir) exportStateDir = path3.resolve(process.cwd());
+    if (!agentName) agentName = path3.basename(exportStateDir);
     await doExport2({ agentName, stateDir: exportStateDir, note, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -1295,7 +2367,7 @@ async function main() {
       console.error("\u274C import \u9700\u8981 --state-dir <path>");
       process.exit(1);
     }
-    if (!agentName) agentName = path2.basename(importStateDir);
+    if (!agentName) agentName = path3.basename(importStateDir);
     await doImport2({ agentName, stateDir: importStateDir, version, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -1320,18 +2392,18 @@ engine7 start \u2014 \u542F\u52A8 Engine
       }
     }
     if (!configPath2) {
-      const defaultCfg = path2.join("configs", "main7.json");
-      const homeCfg = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs2.existsSync(defaultCfg)) {
+      const defaultCfg = path3.join("configs", "main7.json");
+      const homeCfg = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs3.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs2.existsSync(homeCfg)) {
+      } else if (fs3.existsSync(homeCfg)) {
         configPath2 = homeCfg;
         console.log(`   \u4F7F\u7528\u9ED8\u8BA4 config: ${homeCfg}`);
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path2.join(ptr.stateDir, "configs", "main7.json");
-          if (fs2.existsSync(ptrCfg)) {
+          const ptrCfg = path3.join(ptr.stateDir, "configs", "main7.json");
+          if (fs3.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             console.log(`   \u4F7F\u7528 config: ${ptrCfg}`);
           }
@@ -1346,19 +2418,19 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     const { execSync: execSync2, spawn } = await import("node:child_process");
     let enginePath;
-    const localPath = path2.join("node_modules", "engine7", "dist", "main.mjs");
-    if (fs2.existsSync(localPath)) {
+    const localPath = path3.join("node_modules", "engine7", "dist", "main.mjs");
+    if (fs3.existsSync(localPath)) {
       enginePath = localPath;
     } else {
-      const cliPath = path2.resolve(process.argv[1]);
-      const distDir = path2.dirname(cliPath);
-      const candidate = path2.join(distDir, "main.mjs");
-      if (fs2.existsSync(candidate)) {
+      const cliPath = path3.resolve(process.argv[1]);
+      const distDir = path3.dirname(cliPath);
+      const candidate = path3.join(distDir, "main.mjs");
+      if (fs3.existsSync(candidate)) {
         enginePath = candidate;
       } else {
         try {
           const globalRoot = execSync2("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-          enginePath = path2.join(globalRoot, "engine7", "dist", "main.mjs");
+          enginePath = path3.join(globalRoot, "engine7", "dist", "main.mjs");
         } catch {
           console.error("\u274C \u627E\u4E0D\u5230 engine7 main.mjs");
           process.exit(1);
@@ -1368,7 +2440,7 @@ engine7 start \u2014 \u542F\u52A8 Engine
     console.log(label);
     console.log(`   config: ${configPath2}`);
     console.log(`   engine: ${enginePath}`);
-    const configName = path2.basename(configPath2);
+    const configName = path3.basename(configPath2);
     const myPid = process.pid;
     try {
       if (process.platform === "win32") {
@@ -1386,16 +2458,16 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     console.log("");
     const envForChild = { ...process.env };
-    const secretsDir = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-    const cfgBase = path2.basename(configPath2, ".json");
+    const secretsDir = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+    const cfgBase = path3.basename(configPath2, ".json");
     const secretCandidates = [
-      path2.join(secretsDir, `${cfgBase}.env`),
-      path2.join(path2.dirname(configPath2), `.env.${cfgBase}`),
-      path2.join(path2.dirname(configPath2), ".env")
+      path3.join(secretsDir, `${cfgBase}.env`),
+      path3.join(path3.dirname(configPath2), `.env.${cfgBase}`),
+      path3.join(path3.dirname(configPath2), ".env")
     ];
     for (const secretPath of secretCandidates) {
-      if (fs2.existsSync(secretPath)) {
-        const content = fs2.readFileSync(secretPath, "utf-8");
+      if (fs3.existsSync(secretPath)) {
+        const content = fs3.readFileSync(secretPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1469,14 +2541,14 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         console.error(`\u274C \u672A\u77E5\u6A21\u5F0F: ${mode}\uFF08\u53EF\u9009: archive / drop-last / strip-images\uFF09`);
         process.exit(1);
       }
-      const configRaw = JSON.parse(fs2.readFileSync(configPath2, "utf-8"));
+      const configRaw = JSON.parse(fs3.readFileSync(configPath2, "utf-8"));
       const stateDir = configRaw.stateDir;
       if (!stateDir) {
         console.error("\u274C config \u91CC\u6CA1\u6709 stateDir");
         process.exit(1);
       }
-      const sessionsDir = path2.join(stateDir, "agents", "main", "sessions");
-      if (!fs2.existsSync(sessionsDir)) {
+      const sessionsDir = path3.join(stateDir, "agents", "main", "sessions");
+      if (!fs3.existsSync(sessionsDir)) {
         console.error(`\u274C sessions \u76EE\u5F55\u4E0D\u5B58\u5728: ${sessionsDir}`);
         process.exit(1);
       }
@@ -1484,37 +2556,37 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
       console.log(`   config: ${configPath2}`);
       console.log(`   mode:   ${mode}`);
       if (mode === "drop-last") console.log(`   n:      ${dropN}`);
-      const platformMapPath = path2.join(sessionsDir, "platform-map.json");
-      const indexPath = path2.join(sessionsDir, "session-index.json");
+      const platformMapPath = path3.join(sessionsDir, "platform-map.json");
+      const indexPath = path3.join(sessionsDir, "session-index.json");
       let sessionFileUUID = null;
-      if (fs2.existsSync(indexPath)) {
-        const index = JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
+      if (fs3.existsSync(indexPath)) {
+        const index = JSON.parse(fs3.readFileSync(indexPath, "utf-8"));
         const entries = Object.values(index);
         if (entries.length > 0) {
           const fileVal = entries[0].file || "";
-          sessionFileUUID = path2.isAbsolute(fileVal) ? path2.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
+          sessionFileUUID = path3.isAbsolute(fileVal) ? path3.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
         }
       }
       if (!sessionFileUUID) {
-        const jsonlFiles = fs2.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs2.statSync(path2.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+        const jsonlFiles = fs3.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs3.statSync(path3.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error("\u274C \u627E\u4E0D\u5230\u6D3B\u8DC3\u7684 session JSONL \u6587\u4EF6");
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
       }
-      let jsonlPath = path2.join(sessionsDir, `${sessionFileUUID}.jsonl`);
-      if (!fs2.existsSync(jsonlPath)) {
-        const jsonlFiles = fs2.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs2.statSync(path2.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      let jsonlPath = path3.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+      if (!fs3.existsSync(jsonlPath)) {
+        const jsonlFiles = fs3.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs3.statSync(path3.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error(`\u274C JSONL \u6587\u4EF6\u4E0D\u5B58\u5728: ${jsonlPath}`);
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
-        jsonlPath = path2.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+        jsonlPath = path3.join(sessionsDir, `${sessionFileUUID}.jsonl`);
       }
       console.log(`   file:   ${jsonlPath}`);
-      const configName = path2.basename(configPath2);
+      const configName = path3.basename(configPath2);
       if (autoRestart) {
         try {
           const myPid = process.pid;
@@ -1530,15 +2602,15 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         }
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const { readFileSync: readFileSync3, writeFileSync: writeFileSync3, renameSync } = fs2;
+      const { readFileSync: readFileSync4, writeFileSync: writeFileSync4, renameSync } = fs3;
       if (mode === "archive") {
         const archiveName = `${sessionFileUUID}.jsonl.archived.${timestamp}`;
-        renameSync(jsonlPath, path2.join(sessionsDir, archiveName));
+        renameSync(jsonlPath, path3.join(sessionsDir, archiveName));
         console.log(`
 \u2705 \u5F52\u6863\u5B8C\u6210: ${archiveName}`);
         console.log(`   \u91CD\u542F\u540E\u5C06\u4ECE\u7A7A\u767D\u4F1A\u8BDD\u5F00\u59CB`);
       } else if (mode === "drop-last") {
-        const lines = readFileSync3(jsonlPath, "utf-8").trim().split("\n");
+        const lines = readFileSync4(jsonlPath, "utf-8").trim().split("\n");
         const parsed = lines.map((l) => {
           try {
             return JSON.parse(l);
@@ -1557,12 +2629,12 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         }
         const kept = parsed.slice(0, cutIndex);
         const newContent = kept.map((p) => JSON.stringify(p)).join("\n") + "\n";
-        writeFileSync3(jsonlPath, newContent);
+        writeFileSync4(jsonlPath, newContent);
         console.log(`
 \u2705 \u780D\u6389\u6700\u8FD1 ${parsed.length - cutIndex} \u884C\uFF08${dropN} \u8F6E\uFF09`);
         console.log(`   \u4FDD\u7559 ${kept.length} \u884C`);
       } else if (mode === "strip-images") {
-        const lines = readFileSync3(jsonlPath, "utf-8").trim().split("\n");
+        const lines = readFileSync4(jsonlPath, "utf-8").trim().split("\n");
         let stripped = 0;
         const newLines = lines.map((line) => {
           try {
@@ -1603,17 +2675,17 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
             return line;
           }
         });
-        writeFileSync3(jsonlPath, newLines.join("\n") + "\n");
+        writeFileSync4(jsonlPath, newLines.join("\n") + "\n");
         console.log(`
 \u2705 \u6458\u9664 ${stripped} \u884C\u56FE\u7247\u76F8\u5173\u5185\u5BB9`);
       }
       if (autoRestart) {
-        const realCliPath = fs2.realpathSync(process.argv[1]);
-        const cliDir = path2.dirname(realCliPath);
-        const pkgRoot = path2.resolve(cliDir, "..");
-        let enginePath = path2.join(pkgRoot, "dist", "main.mjs");
-        if (!fs2.existsSync(enginePath)) {
-          enginePath = path2.join(cliDir, "main.mjs");
+        const realCliPath = fs3.realpathSync(process.argv[1]);
+        const cliDir = path3.dirname(realCliPath);
+        const pkgRoot = path3.resolve(cliDir, "..");
+        let enginePath = path3.join(pkgRoot, "dist", "main.mjs");
+        if (!fs3.existsSync(enginePath)) {
+          enginePath = path3.join(cliDir, "main.mjs");
         }
         console.log(`
 \u{1F680} \u62C9\u8D77 engine...`);
@@ -1656,18 +2728,18 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       else if (args[i] === "--cwd" && args[i + 1]) cwd = args[++i];
     }
     if (!configPath2) {
-      const defaultCfg = path2.join(cwd, "configs", "main7.json");
-      const homeCfg = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs2.existsSync(defaultCfg)) {
+      const defaultCfg = path3.join(cwd, "configs", "main7.json");
+      const homeCfg = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs3.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs2.existsSync(homeCfg)) {
+      } else if (fs3.existsSync(homeCfg)) {
         configPath2 = homeCfg;
-        cwd = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        cwd = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path2.join(ptr.stateDir, "configs", "main7.json");
-          if (fs2.existsSync(ptrCfg)) {
+          const ptrCfg = path3.join(ptr.stateDir, "configs", "main7.json");
+          if (fs3.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             cwd = ptr.stateDir;
           }
@@ -1686,14 +2758,14 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       if (process.platform === "win32") {
         const taskName = "Engine7";
         const nodeExe = process.execPath;
-        const cliMjs = path2.resolve(engine7Bin);
-        const absConfig = path2.resolve(configPath2);
-        const wrapperPath = path2.join(cwd, "engine7-start.cmd");
+        const cliMjs = path3.resolve(engine7Bin);
+        const absConfig = path3.resolve(configPath2);
+        const wrapperPath = path3.join(cwd, "engine7-start.cmd");
         const wrapperContent = `@echo off\r
 cd /d "${cwd}"\r
 "${nodeExe}" "${cliMjs}" start --config "${absConfig}"\r
 `;
-        fs2.writeFileSync(wrapperPath, wrapperContent);
+        fs3.writeFileSync(wrapperPath, wrapperContent);
         try {
           execSync2(`schtasks /create /tn "${taskName}" /tr "${wrapperPath}" /sc onlogon /rl highest /f`, { stdio: "inherit", shell: true });
           console.log(`\u2705 Windows \u8BA1\u5212\u4EFB\u52A1 "${taskName}" \u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -1704,11 +2776,11 @@ cd /d "${cwd}"\r
         }
       } else if (process.platform === "darwin") {
         const label = "com.engine7.agent";
-        const plistDir = path2.join(process.env.HOME, "Library", "LaunchAgents");
-        fs2.mkdirSync(plistDir, { recursive: true });
-        const plistPath = path2.join(plistDir, `${label}.plist`);
-        const localCli = path2.join("node_modules", "engine7", "dist", "cli.mjs");
-        const cliMjs = fs2.existsSync(localCli) ? path2.resolve(localCli) : path2.join(path2.dirname(path2.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
+        const plistDir = path3.join(process.env.HOME, "Library", "LaunchAgents");
+        fs3.mkdirSync(plistDir, { recursive: true });
+        const plistPath = path3.join(plistDir, `${label}.plist`);
+        const localCli = path3.join("node_modules", "engine7", "dist", "cli.mjs");
+        const cliMjs = fs3.existsSync(localCli) ? path3.resolve(localCli) : path3.join(path3.dirname(path3.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
         const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -1720,14 +2792,14 @@ cd /d "${cwd}"\r
     <string>${cliMjs}</string>
     <string>start</string>
     <string>--config</string>
-    <string>${path2.resolve(configPath2)}</string>
+    <string>${path3.resolve(configPath2)}</string>
   </array>
   <key>WorkingDirectory</key><string>${cwd}</string>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
 </dict>
 </plist>`;
-        fs2.writeFileSync(plistPath, plist);
+        fs3.writeFileSync(plistPath, plist);
         try {
           execSync2(`launchctl load "${plistPath}"`, { stdio: "inherit" });
           console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -1738,9 +2810,9 @@ cd /d "${cwd}"\r
         }
       } else {
         const svcName = "engine7";
-        const svcDir = path2.join(process.env.HOME, ".config", "systemd", "user");
-        fs2.mkdirSync(svcDir, { recursive: true });
-        const svcPath = path2.join(svcDir, `${svcName}.service`);
+        const svcDir = path3.join(process.env.HOME, ".config", "systemd", "user");
+        fs3.mkdirSync(svcDir, { recursive: true });
+        const svcPath = path3.join(svcDir, `${svcName}.service`);
         const svc = `[Unit]
 Description=Engine 7 Agent
 After=network.target
@@ -1748,13 +2820,13 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=${cwd}
-ExecStart=${process.execPath} ${engine7Bin} start --config ${path2.resolve(configPath2)}
+ExecStart=${process.execPath} ${engine7Bin} start --config ${path3.resolve(configPath2)}
 Restart=on-failure
 RestartSec=10
 
 [Install]
 WantedBy=default.target`;
-        fs2.writeFileSync(svcPath, svc);
+        fs3.writeFileSync(svcPath, svc);
         try {
           execSync2(`systemctl --user daemon-reload`, { stdio: "inherit" });
           execSync2(`systemctl --user enable ${svcName}`, { stdio: "inherit" });
@@ -1775,13 +2847,13 @@ WantedBy=default.target`;
           process.exit(1);
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path2.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        const plistPath = path3.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
         try {
           execSync2(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
         } catch {
         }
         try {
-          fs2.unlinkSync(plistPath);
+          fs3.unlinkSync(plistPath);
         } catch {
         }
         console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u5220\u9664`);
@@ -1790,9 +2862,9 @@ WantedBy=default.target`;
           execSync2(`systemctl --user disable engine7`, { stdio: "inherit" });
         } catch {
         }
-        const svcPath = path2.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
+        const svcPath = path3.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
         try {
-          fs2.unlinkSync(svcPath);
+          fs3.unlinkSync(svcPath);
         } catch {
         }
         try {
@@ -1809,8 +2881,8 @@ WantedBy=default.target`;
           console.log("\u274C \u672A\u5B89\u88C5");
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path2.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
-        if (fs2.existsSync(plistPath)) {
+        const plistPath = path3.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        if (fs3.existsSync(plistPath)) {
           console.log("\u2705 \u5DF2\u5B89\u88C5\uFF08launchd\uFF09");
         } else {
           console.log("\u274C \u672A\u5B89\u88C5");
@@ -1833,13 +2905,13 @@ WantedBy=default.target`;
   console.log(`
 \u{1F680} engine7 init`);
   console.log(`   state-dir: ${opts.stateDir}`);
-  if (fs2.existsSync(opts.stateDir) && !opts.dryRun) {
-    const files = fs2.readdirSync(opts.stateDir);
+  if (fs3.existsSync(opts.stateDir) && !opts.dryRun) {
+    const files = fs3.readdirSync(opts.stateDir);
     if (files.length > 0) {
       if (opts.force) {
         console.log(`
 \u26A0\uFE0F --force: \u6E05\u7A7A\u5DF2\u6709\u76EE\u5F55 ${opts.stateDir}`);
-        fs2.rmSync(opts.stateDir, { recursive: true, force: true });
+        fs3.rmSync(opts.stateDir, { recursive: true, force: true });
       } else {
         console.error(`
 \u274C \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A: ${opts.stateDir}`);
@@ -1859,7 +2931,7 @@ WantedBy=default.target`;
     rl.close();
   }
   const config = generateConfig(values);
-  const configPath = path2.join(opts.stateDir, "configs", "main7.json");
+  const configPath = path3.join(opts.stateDir, "configs", "main7.json");
   const tree = buildDirTree(values);
   tree.push({
     path: configPath,
@@ -1870,9 +2942,9 @@ WantedBy=default.target`;
     dryRun(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skills = fs2.readdirSync(skillsSrc);
+      const skills = fs3.readdirSync(skillsSrc);
       for (const s of skills) {
-        console.log(`  \u{1F4C1} ${path2.join(opts.stateDir, "workspace", "skills", s)}`);
+        console.log(`  \u{1F4C1} ${path3.join(opts.stateDir, "workspace", "skills", s)}`);
       }
     }
   } else {
@@ -1880,55 +2952,55 @@ WantedBy=default.target`;
     execute(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skillsDest = path2.join(opts.stateDir, "workspace", "skills");
-      fs2.mkdirSync(skillsDest, { recursive: true });
-      const skills = fs2.readdirSync(skillsSrc);
+      const skillsDest = path3.join(opts.stateDir, "workspace", "skills");
+      fs3.mkdirSync(skillsDest, { recursive: true });
+      const skills = fs3.readdirSync(skillsSrc);
       for (const s of skills) {
-        copyDirRecursive(path2.join(skillsSrc, s), path2.join(skillsDest, s));
+        copyDirRecursive(path3.join(skillsSrc, s), path3.join(skillsDest, s));
         console.log(`  \u{1F4E6} skill: ${s}`);
       }
     }
     console.log(`
 \u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01
 `);
-    const homePointer = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+    const homePointer = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
     const pointerData = { stateDir: opts.stateDir };
-    fs2.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
+    fs3.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
     console.log(`   \u{1F4C4} ${homePointer}\uFF08\u4ECE\u4EFB\u610F\u76EE\u5F55\u90FD\u80FD\u627E\u5230\u6B64 agent\uFF09`);
     console.log(`\u4E0B\u4E00\u6B65\uFF1A`);
     console.log(`  1. \u68C0\u67E5\u5E76\u4FEE\u6539 ${opts.stateDir}/configs/main7.json`);
     console.log(`  2. \u542F\u52A8 Engine: engine7 start\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
     console.log(`  3. \u5F00\u673A\u81EA\u542F: engine7 service install\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
-    console.log(`  4. \u67E5\u770B workspace: ${path2.join(opts.stateDir, "workspace")}`);
+    console.log(`  4. \u67E5\u770B workspace: ${path3.join(opts.stateDir, "workspace")}`);
   }
 }
 function copyDirRecursive(src, dest) {
-  fs2.mkdirSync(dest, { recursive: true });
-  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path2.join(src, entry.name);
-    const destPath = path2.join(dest, entry.name);
+  fs3.mkdirSync(dest, { recursive: true });
+  for (const entry of fs3.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs2.copyFileSync(srcPath, destPath);
+      fs3.copyFileSync(srcPath, destPath);
     }
   }
 }
 function findTemplateDir(name) {
   const candidates = [
-    path2.join(__dirname, "..", "templates", name),
-    path2.join(__dirname, "..", "..", "templates", name),
-    path2.join(process.cwd(), "templates", name)
+    path3.join(__dirname, "..", "templates", name),
+    path3.join(__dirname, "..", "..", "templates", name),
+    path3.join(process.cwd(), "templates", name)
   ];
   for (const p of candidates) {
-    if (fs2.existsSync(p)) return p;
+    if (fs3.existsSync(p)) return p;
   }
   return null;
 }
 function readHomePointer() {
-  const ptrPath = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+  const ptrPath = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
   try {
-    return JSON.parse(fs2.readFileSync(ptrPath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(ptrPath, "utf-8"));
   } catch {
     return null;
   }