engine7 7.1.41 → 7.1.43

package/dist/cli.mjs

@@ -14,185 +14,1280 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/cli-travel.ts
-var cli_travel_exports = {};
-__export(cli_travel_exports, {
-  doExport: () => doExport,
-  doImport: () => doImport,
-  loadTravelConfig: () => loadTravelConfig,
-  saveTravelConfig: () => saveTravelConfig
+// src/feishu-quick-register.ts
+var feishu_quick_register_exports = {};
+__export(feishu_quick_register_exports, {
+  registerFeishuApp: () => registerFeishuApp
 });
-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 (!fs2.existsSync(CONFIG_PATH)) return null;
-    return JSON.parse(fs2.readFileSync(CONFIG_PATH, "utf-8"));
-  } catch {
-    return null;
+async function postRegistration(domain, body) {
+  const url = `${ACCOUNTS_URL[domain]}${REGISTRATION_PATH}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(body).toString(),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`\u98DE\u4E66\u6CE8\u518C\u63A5\u53E3\u8FD4\u56DE ${res.status}: ${await res.text()}`);
   }
+  return res.json();
 }
-function saveTravelConfig(cfg) {
-  fs2.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+async function initRegistration(domain) {
+  const res = await postRegistration(domain, { action: "init" });
+  if (!res.supported_auth_methods?.includes("client_secret")) {
+    throw new Error("\u5F53\u524D\u98DE\u4E66\u73AF\u5883\u4E0D\u652F\u6301 client_secret \u8BA4\u8BC1\uFF0C\u65E0\u6CD5\u81EA\u52A8\u6CE8\u518C");
+  }
 }
-function sanitizeContent(content, dirs) {
-  let result = content;
-  for (const { placeholder, getOriginal } of PATH_PLACEHOLDERS) {
-    const original = getOriginal(dirs);
-    if (original) {
-      result = result.split(original).join(placeholder);
-      result = result.split(original.replace(/\//g, "\\")).join(placeholder);
-      result = result.split(original.replace(/\//g, "\\\\")).join(placeholder);
-    }
+async function beginRegistration(domain) {
+  const res = await postRegistration(domain, {
+    action: "begin",
+    archetype: "PersonalAgent",
+    auth_method: "client_secret",
+    request_user_info: "open_id"
+  });
+  if (!res.device_code || !res.verification_uri_complete) {
+    throw new Error(`\u98DE\u4E66\u6CE8\u518C\u5931\u8D25: \u672A\u8FD4\u56DE device_code
+${JSON.stringify(res)}`);
   }
-  return result;
+  return {
+    deviceCode: res.device_code,
+    qrUrl: res.verification_uri_complete,
+    userCode: res.user_code,
+    interval: res.interval ?? DEFAULT_POLL_INTERVAL,
+    expireIn: res.expire_in ?? 300
+  };
 }
-function restoreContent(content, dirs) {
-  let result = content;
-  for (const { placeholder, getOriginal } of PATH_PLACEHOLDERS) {
-    const target = getOriginal(dirs);
-    if (target) {
-      result = result.split(placeholder).join(target);
+async function pollRegistration(domain, deviceCode, interval, deadline, onLog, signal) {
+  let currentInterval = interval;
+  let currentDomain = domain;
+  while (Date.now() < deadline) {
+    if (signal?.aborted) return null;
+    let res;
+    try {
+      res = await postRegistration(currentDomain, {
+        action: "poll",
+        device_code: deviceCode
+      });
+    } catch {
+      await sleep(currentInterval * 1e3);
+      continue;
+    }
+    if (res.user_info?.tenant_brand === "lark" && currentDomain === "feishu") {
+      currentDomain = "lark";
+      onLog?.("\u68C0\u6D4B\u5230 Lark \u8D26\u53F7\uFF0C\u5207\u6362\u57DF\u540D...");
+      continue;
+    }
+    if (res.client_id && res.client_secret) {
+      return {
+        appId: res.client_id,
+        appSecret: res.client_secret,
+        openId: res.user_info?.open_id,
+        domain: currentDomain
+      };
     }
+    if (res.error) {
+      if (res.error === "authorization_pending") {
+      } else if (res.error === "slow_down") {
+        currentInterval += 5;
+      } else if (res.error === "access_denied") {
+        throw new Error("\u7528\u6237\u62D2\u7EDD\u4E86\u6388\u6743");
+      } else if (res.error === "expired_token") {
+        throw new Error("\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
+      } else {
+        throw new Error(`\u98DE\u4E66\u6CE8\u518C\u9519\u8BEF: ${res.error} \u2014 ${res.error_description ?? ""}`);
+      }
+    }
+    await sleep(currentInterval * 1e3);
+  }
+  return null;
+}
+async function registerFeishuApp(options = {}) {
+  const domain = options.domain ?? "feishu";
+  const timeoutSec = options.timeoutSec ?? 300;
+  const log = options.onLog ?? (() => {
+  });
+  log("\u68C0\u67E5\u98DE\u4E66\u73AF\u5883...");
+  await initRegistration(domain);
+  log("\u751F\u6210\u4E8C\u7EF4\u7801...");
+  const { deviceCode, qrUrl, interval, expireIn } = await beginRegistration(domain);
+  options.onQrCode?.(qrUrl);
+  log(`\u8BF7\u7528\u98DE\u4E66 App \u626B\u63CF\u4E8C\u7EF4\u7801\uFF08${expireIn}\u79D2\u540E\u8FC7\u671F\uFF09...`);
+  const deadline = Date.now() + Math.min(expireIn, timeoutSec) * 1e3;
+  const result = await pollRegistration(domain, deviceCode, interval, deadline, log, options.signal);
+  if (result) {
+    log(`\u2705 \u6CE8\u518C\u6210\u529F\uFF01App ID: ${result.appId}`);
+  } else {
+    log("\u23F0 \u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
   }
   return result;
 }
-function isTextFile(filePath) {
-  const ext = path2.extname(filePath).toLowerCase();
-  return TEXT_EXTENSIONS.has(ext);
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function shouldExclude(name) {
-  for (const pattern of WORKSPACE_EXCLUDE) {
-    if (pattern.startsWith("*")) {
-      if (name.includes(pattern.slice(1).replace("*", ""))) return true;
-    } else if (name === pattern) {
-      return true;
+var ACCOUNTS_URL, REGISTRATION_PATH, REQUEST_TIMEOUT_MS, DEFAULT_POLL_INTERVAL;
+var init_feishu_quick_register = __esm({
+  "src/feishu-quick-register.ts"() {
+    "use strict";
+    ACCOUNTS_URL = {
+      feishu: "https://accounts.feishu.cn",
+      lark: "https://accounts.larksuite.com"
+    };
+    REGISTRATION_PATH = "/oauth/v1/app/registration";
+    REQUEST_TIMEOUT_MS = 1e4;
+    DEFAULT_POLL_INTERVAL = 5;
+  }
+});
+
+// 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 collectFiles(rootDir, includeSet, optionalSet) {
-  const files = [];
-  const entries = fs2.readdirSync(rootDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (shouldExclude(entry.name)) continue;
-    const fullPath = path2.join(rootDir, entry.name);
-    const realPath = fs2.realpathSync(fullPath);
-    if (realPath !== fullPath) {
-      try {
-        const lstat = fs2.lstatSync(fullPath);
-        if (lstat.isSymbolicLink()) {
-          continue;
-        }
-      } catch {
+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;
     }
-    const isInclude = includeSet.has(entry.name) || optionalSet.has(entry.name);
-    if (!isInclude) continue;
-    if (entry.isDirectory()) {
-      const subFiles = collectAllFiles(fullPath);
-      files.push(...subFiles);
+  }
+  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 {
-      files.push(fullPath);
+      result.push(line);
     }
   }
-  return files;
+  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 collectAllFiles(dir) {
-  const files = [];
+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 entries = fs2.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (shouldExclude(entry.name)) continue;
-      const fullPath = path2.join(dir, entry.name);
-      try {
-        if (fs2.lstatSync(fullPath).isSymbolicLink()) continue;
-      } catch {
-      }
-      if (entry.isDirectory()) {
-        files.push(...collectAllFiles(fullPath));
-      } else {
-        files.push(fullPath);
-      }
-    }
+    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 files;
+  return "";
 }
-function readMainEngineUuid(agentsDir) {
+function saveSyncBuf(stateDir, accountId, buf) {
   try {
-    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(fs2.readFileSync(indexMapPath, "utf-8"));
-    const entry = indexMap[mainPlatformId];
-    if (!entry || !entry.file) return null;
-    const basename4 = path2.basename(entry.file).replace(/\.jsonl$/, "");
-    return basename4;
+    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 {
-    return null;
   }
 }
-function collectRecentSessions(agentsDir, _days = 7) {
-  const files = [];
-  if (!fs2.existsSync(agentsDir)) return files;
-  const sessionGroups = /* @__PURE__ */ new Map();
-  function scanSessionsDir(dir) {
+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 {
-      const entries = fs2.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          scanSessionsDir(fullPath);
-          continue;
+      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
         }
-        if (entry.name === "platform-map.json" || entry.name === "session-index.json") {
-          files.push(fullPath);
-          continue;
+      }, 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 {
         }
-        let sessionKey = null;
-        if (entry.name.endsWith(".jsonl")) {
-          sessionKey = entry.name.slice(0, -6);
+      }
+      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 {
-          const m = entry.name.match(/^(.+)\.jsonl\.(archived|compaction)\./);
-          if (m) sessionKey = m[1];
+          if (!this.isDmAllowed(senderId)) return;
         }
-        if (!sessionKey) continue;
-        if (!sessionGroups.has(sessionKey)) {
-          sessionGroups.set(sessionKey, { archived: [] });
+        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);
         }
-        const group = sessionGroups.get(sessionKey);
-        if (entry.name.endsWith(".jsonl")) {
-          group.jsonl = fullPath;
+        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 {
-          const stat = fs2.statSync(fullPath);
-          group.archived.push({ file: fullPath, mtime: stat.mtimeMs });
+          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 };
       }
-    } catch {
-    }
-  }
-  scanSessionsDir(agentsDir);
-  const mainEngineUuid = readMainEngineUuid(agentsDir);
-  for (const [sessionKey, group] of sessionGroups) {
-    if (!mainEngineUuid || !sessionKey.startsWith(mainEngineUuid)) continue;
-    if (group.jsonl) files.push(group.jsonl);
-    group.archived.sort((a, b) => b.mtime - a.mtime);
-    if (group.archived.length > 0) files.push(group.archived[0].file);
+      // --- 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;
   }
-  return files;
+});
+
+// src/qr-render.ts
+var qr_render_exports = {};
+__export(qr_render_exports, {
+  renderQrTerminal: () => renderQrTerminal
+});
+import { createRequire } from "node:module";
+async function renderQrTerminal(url, options) {
+  return new Promise((resolve2, reject) => {
+    try {
+      const qt = require2("qrcode-terminal");
+      qt.generate(url, { small: options?.small ?? true }, (output) => {
+        resolve2(output);
+      });
+    } catch (err) {
+      reject(err);
+    }
+  });
 }
-async function doExport(opts) {
-  const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
-  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}`);
+var require2;
+var init_qr_render = __esm({
+  "src/qr-render.ts"() {
+    "use strict";
+    require2 = createRequire(import.meta.url);
+  }
+});
+
+// src/cli-travel.ts
+var cli_travel_exports = {};
+__export(cli_travel_exports, {
+  doExport: () => doExport,
+  doImport: () => doImport,
+  loadTravelConfig: () => loadTravelConfig,
+  saveTravelConfig: () => saveTravelConfig
+});
+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 (!fs2.existsSync(CONFIG_PATH)) return null;
+    return JSON.parse(fs2.readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveTravelConfig(cfg) {
+  fs2.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}
+function sanitizeContent(content, dirs) {
+  let result = content;
+  for (const { placeholder, getOriginal } of PATH_PLACEHOLDERS) {
+    const original = getOriginal(dirs);
+    if (original) {
+      result = result.split(original).join(placeholder);
+      result = result.split(original.replace(/\//g, "\\")).join(placeholder);
+      result = result.split(original.replace(/\//g, "\\\\")).join(placeholder);
+    }
+  }
+  return result;
+}
+function restoreContent(content, dirs) {
+  let result = content;
+  for (const { placeholder, getOriginal } of PATH_PLACEHOLDERS) {
+    const target = getOriginal(dirs);
+    if (target) {
+      result = result.split(placeholder).join(target);
+    }
+  }
+  return result;
+}
+function isTextFile(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  return TEXT_EXTENSIONS.has(ext);
+}
+function shouldExclude(name) {
+  for (const pattern of WORKSPACE_EXCLUDE) {
+    if (pattern.startsWith("*")) {
+      if (name.includes(pattern.slice(1).replace("*", ""))) return true;
+    } else if (name === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectFiles(rootDir, includeSet, optionalSet) {
+  const files = [];
+  const entries = fs2.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldExclude(entry.name)) continue;
+    const fullPath = path2.join(rootDir, entry.name);
+    const realPath = fs2.realpathSync(fullPath);
+    if (realPath !== fullPath) {
+      try {
+        const lstat = fs2.lstatSync(fullPath);
+        if (lstat.isSymbolicLink()) {
+          continue;
+        }
+      } catch {
+      }
+    }
+    const isInclude = includeSet.has(entry.name) || optionalSet.has(entry.name);
+    if (!isInclude) continue;
+    if (entry.isDirectory()) {
+      const subFiles = collectAllFiles(fullPath);
+      files.push(...subFiles);
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function collectAllFiles(dir) {
+  const files = [];
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (shouldExclude(entry.name)) continue;
+      const fullPath = path2.join(dir, entry.name);
+      try {
+        if (fs2.lstatSync(fullPath).isSymbolicLink()) continue;
+      } catch {
+      }
+      if (entry.isDirectory()) {
+        files.push(...collectAllFiles(fullPath));
+      } else {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function readMainEngineUuid(agentsDir) {
+  try {
+    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(fs2.readFileSync(indexMapPath, "utf-8"));
+    const entry = indexMap[mainPlatformId];
+    if (!entry || !entry.file) return null;
+    const basename4 = path2.basename(entry.file).replace(/\.jsonl$/, "");
+    return basename4;
+  } catch {
+    return null;
+  }
+}
+function collectRecentSessions(agentsDir, _days = 7) {
+  const files = [];
+  if (!fs2.existsSync(agentsDir)) return files;
+  const sessionGroups = /* @__PURE__ */ new Map();
+  function scanSessionsDir(dir) {
+    try {
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanSessionsDir(fullPath);
+          continue;
+        }
+        if (entry.name === "platform-map.json" || entry.name === "session-index.json") {
+          files.push(fullPath);
+          continue;
+        }
+        let sessionKey = null;
+        if (entry.name.endsWith(".jsonl")) {
+          sessionKey = entry.name.slice(0, -6);
+        } else {
+          const m = entry.name.match(/^(.+)\.jsonl\.(archived|compaction)\./);
+          if (m) sessionKey = m[1];
+        }
+        if (!sessionKey) continue;
+        if (!sessionGroups.has(sessionKey)) {
+          sessionGroups.set(sessionKey, { archived: [] });
+        }
+        const group = sessionGroups.get(sessionKey);
+        if (entry.name.endsWith(".jsonl")) {
+          group.jsonl = fullPath;
+        } else {
+          const stat = fs2.statSync(fullPath);
+          group.archived.push({ file: fullPath, mtime: stat.mtimeMs });
+        }
+      }
+    } catch {
+    }
+  }
+  scanSessionsDir(agentsDir);
+  const mainEngineUuid = readMainEngineUuid(agentsDir);
+  for (const [sessionKey, group] of sessionGroups) {
+    if (!mainEngineUuid || !sessionKey.startsWith(mainEngineUuid)) continue;
+    if (group.jsonl) files.push(group.jsonl);
+    group.archived.sort((a, b) => b.mtime - a.mtime);
+    if (group.archived.length > 0) files.push(group.archived[0].file);
+  }
+  return files;
+}
+async function doExport(opts) {
+  const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
+  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 (!fs2.existsSync(workspace)) {
@@ -446,442 +1541,191 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
   const tag = `${agentName}-${version}`;
   console.log(`
 \u{1F4E4} \u4E0A\u4F20\u5230 GitHub: ${repo} release ${tag}`);
-  try {
-    const releaseBody = Object.entries(manifest).map(([k, v]) => `- **${k}**: ${typeof v === "object" ? JSON.stringify(v) : v}`).join("\n");
-    const createRes = await fetch(`https://api.github.com/repos/${repo}/releases`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${cfg.githubToken}`,
-        "Accept": "application/vnd.github+json",
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        tag_name: tag,
-        name: `${agentName} ${version}`,
-        body: releaseBody,
-        prerelease: false,
-        make_latest: "true"
-      })
-    });
-    if (!createRes.ok) {
-      const err = await createRes.text();
-      throw new Error(`\u521B\u5EFA release \u5931\u8D25: ${createRes.status} ${err}`);
-    }
-    const release = await createRes.json();
-    const uploadUrl = release.upload_url.replace("{?name,label}", "");
-    const fileBuffer = fs2.readFileSync(archiveFile);
-    const fileName = path2.basename(archiveFile);
-    const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${cfg.githubToken}`,
-        "Accept": "application/vnd.github+json",
-        "Content-Type": "application/gzip",
-        "Content-Length": String(fileBuffer.length)
-      },
-      body: fileBuffer
-    });
-    if (!uploadRes.ok) {
-      const err = await uploadRes.text();
-      throw new Error(`\u4E0A\u4F20 asset \u5931\u8D25: ${uploadRes.status} ${err}`);
-    }
-    console.log(`\u2705 \u4E0A\u4F20\u6210\u529F!`);
-    console.log(`   release: ${release.html_url}`);
-  } catch (e) {
-    console.error(`\u274C GitHub \u4E0A\u4F20\u5931\u8D25: ${e.message}`);
-    console.error(`   archive \u4ECD\u5728: ${archiveFile}`);
-    throw e;
-  }
-  try {
-    fs2.rmSync(path2.dirname(archiveFile), { recursive: true, force: true });
-  } catch {
-  }
-}
-async function downloadFromGitHub(cfg, agentName, version, destDir) {
-  const repo = `${cfg.githubOwner}/${cfg.repoName}`;
-  const tag = version || await getLatestReleaseTag(cfg, agentName);
-  console.log(`\u2B07\uFE0F  \u4E0B\u8F7D: ${repo} release ${tag}`);
-  const res = await fetch(`https://api.github.com/repos/${repo}/releases/tags/${tag}`, {
-    headers: {
-      "Authorization": `Bearer ${cfg.githubToken}`,
-      "Accept": "application/vnd.github+json"
-    }
-  });
-  if (!res.ok) {
-    throw new Error(`\u83B7\u53D6 release \u5931\u8D25: ${res.status}`);
-  }
-  const release = await res.json();
-  const asset = release.assets?.find((a) => a.name.endsWith(".tar.gz") || a.name.endsWith(".zip"));
-  if (!asset) {
-    throw new Error(`release ${tag} \u6CA1\u6709 tar.gz/zip asset`);
-  }
-  const downloadRes = await fetch(asset.url, {
-    headers: {
-      "Authorization": `Bearer ${cfg.githubToken}`,
-      "Accept": "application/octet-stream"
-    }
-  });
-  if (!downloadRes.ok) {
-    throw new Error(`\u4E0B\u8F7D asset \u5931\u8D25: ${downloadRes.status}`);
-  }
-  const buffer = Buffer.from(await downloadRes.arrayBuffer());
-  const archiveFile = path2.join(destDir, asset.name);
-  fs2.writeFileSync(archiveFile, buffer);
-  return archiveFile;
-}
-async function getLatestReleaseTag(cfg, agentName) {
-  const repo = `${cfg.githubOwner}/${cfg.repoName}`;
-  const res = await fetch(`https://api.github.com/repos/${repo}/releases?per_page=30`, {
-    headers: {
-      "Authorization": `Bearer ${cfg.githubToken}`,
-      "Accept": "application/vnd.github+json"
-    }
-  });
-  if (!res.ok) {
-    throw new Error(`\u83B7\u53D6 release \u5217\u8868\u5931\u8D25: ${res.status}`);
-  }
-  const releases = await res.json();
-  const match = releases.find((r) => r.tag_name?.startsWith(`${agentName}-`));
-  if (!match) {
-    throw new Error(`\u6CA1\u6709\u627E\u5230 ${agentName} \u7684 release`);
-  }
-  return match.tag_name;
-}
-var CONFIG_PATH, PATH_PLACEHOLDERS, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL, WORKSPACE_EXCLUDE, TEXT_EXTENSIONS;
-var init_cli_travel = __esm({
-  "src/cli-travel.ts"() {
-    "use strict";
-    CONFIG_PATH = path2.join(os2.homedir(), ".engine7-travel.json");
-    PATH_PLACEHOLDERS = [
-      { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
-      { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
-      { placeholder: "{{STATE_DIR}}", getOriginal: (d) => d.stateDir }
-    ];
-    WORKSPACE_INCLUDE = /* @__PURE__ */ new Set([
-      // 核心文件
-      "AGENTS.md",
-      "SOUL.md",
-      "MEMORY.md",
-      "USER.md",
-      "HEARTBEAT.md",
-      "INDEX.md",
-      "SESSION-STATE.md",
-      // 核心目录
-      "prompts",
-      "topics",
-      "memory",
-      "inner-voice",
-      "docs",
-      "skills",
-      "voice-chat",
-      "scripts",
-      "selfie",
-      "moodboard",
-      // 状态文件 + 目录
-      ".calendar",
-      "nudge-state.json"
-    ]);
-    WORKSPACE_OPTIONAL = /* @__PURE__ */ new Set([
-      "images",
-      "tools"
-    ]);
-    WORKSPACE_EXCLUDE = /* @__PURE__ */ new Set([
-      "livestream",
-      "content-library",
-      "tmp",
-      ".git",
-      "node_modules",
-      "memory_runs",
-      "workspace",
-      "prompt-archive",
-      "aim-archive",
-      "test-agent",
-      "nul",
-      "*.bak*",
-      "*.bak-*",
-      "~$*"
-    ]);
-    TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".md",
-      ".json",
-      ".txt",
-      ".js",
-      ".ts",
-      ".mjs",
-      ".py",
-      ".yaml",
-      ".yml",
-      ".cmd",
-      ".bat",
-      ".sh",
-      ".csv",
-      ".html",
-      ".toml",
-      ".list"
-      // .everos 的 everos.toml/config.toml/ome.toml/everos-env.list
-    ]);
-  }
-});
-
-// src/cli-init.ts
-import * as path3 from "node:path";
-import * as fs3 from "node:fs";
-import * as readline from "node:readline";
-import { fileURLToPath } from "node:url";
-
-// src/feishu-quick-register.ts
-var ACCOUNTS_URL = {
-  feishu: "https://accounts.feishu.cn",
-  lark: "https://accounts.larksuite.com"
-};
-var REGISTRATION_PATH = "/oauth/v1/app/registration";
-var REQUEST_TIMEOUT_MS = 1e4;
-var DEFAULT_POLL_INTERVAL = 5;
-async function postRegistration(domain, body) {
-  const url = `${ACCOUNTS_URL[domain]}${REGISTRATION_PATH}`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams(body).toString(),
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-  });
-  if (!res.ok) {
-    throw new Error(`\u98DE\u4E66\u6CE8\u518C\u63A5\u53E3\u8FD4\u56DE ${res.status}: ${await res.text()}`);
-  }
-  return res.json();
-}
-async function initRegistration(domain) {
-  const res = await postRegistration(domain, { action: "init" });
-  if (!res.supported_auth_methods?.includes("client_secret")) {
-    throw new Error("\u5F53\u524D\u98DE\u4E66\u73AF\u5883\u4E0D\u652F\u6301 client_secret \u8BA4\u8BC1\uFF0C\u65E0\u6CD5\u81EA\u52A8\u6CE8\u518C");
-  }
-}
-async function beginRegistration(domain) {
-  const res = await postRegistration(domain, {
-    action: "begin",
-    archetype: "PersonalAgent",
-    auth_method: "client_secret",
-    request_user_info: "open_id"
-  });
-  if (!res.device_code || !res.verification_uri_complete) {
-    throw new Error(`\u98DE\u4E66\u6CE8\u518C\u5931\u8D25: \u672A\u8FD4\u56DE device_code
-${JSON.stringify(res)}`);
-  }
-  return {
-    deviceCode: res.device_code,
-    qrUrl: res.verification_uri_complete,
-    userCode: res.user_code,
-    interval: res.interval ?? DEFAULT_POLL_INTERVAL,
-    expireIn: res.expire_in ?? 300
-  };
-}
-async function pollRegistration(domain, deviceCode, interval, deadline, onLog, signal) {
-  let currentInterval = interval;
-  let currentDomain = domain;
-  while (Date.now() < deadline) {
-    if (signal?.aborted) return null;
-    let res;
-    try {
-      res = await postRegistration(currentDomain, {
-        action: "poll",
-        device_code: deviceCode
-      });
-    } catch {
-      await sleep(currentInterval * 1e3);
-      continue;
-    }
-    if (res.user_info?.tenant_brand === "lark" && currentDomain === "feishu") {
-      currentDomain = "lark";
-      onLog?.("\u68C0\u6D4B\u5230 Lark \u8D26\u53F7\uFF0C\u5207\u6362\u57DF\u540D...");
-      continue;
-    }
-    if (res.client_id && res.client_secret) {
-      return {
-        appId: res.client_id,
-        appSecret: res.client_secret,
-        openId: res.user_info?.open_id,
-        domain: currentDomain
-      };
-    }
-    if (res.error) {
-      if (res.error === "authorization_pending") {
-      } else if (res.error === "slow_down") {
-        currentInterval += 5;
-      } else if (res.error === "access_denied") {
-        throw new Error("\u7528\u6237\u62D2\u7EDD\u4E86\u6388\u6743");
-      } else if (res.error === "expired_token") {
-        throw new Error("\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
-      } else {
-        throw new Error(`\u98DE\u4E66\u6CE8\u518C\u9519\u8BEF: ${res.error} \u2014 ${res.error_description ?? ""}`);
-      }
-    }
-    await sleep(currentInterval * 1e3);
-  }
-  return null;
-}
-async function registerFeishuApp(options = {}) {
-  const domain = options.domain ?? "feishu";
-  const timeoutSec = options.timeoutSec ?? 300;
-  const log = options.onLog ?? (() => {
-  });
-  log("\u68C0\u67E5\u98DE\u4E66\u73AF\u5883...");
-  await initRegistration(domain);
-  log("\u751F\u6210\u4E8C\u7EF4\u7801...");
-  const { deviceCode, qrUrl, interval, expireIn } = await beginRegistration(domain);
-  options.onQrCode?.(qrUrl);
-  log(`\u8BF7\u7528\u98DE\u4E66 App \u626B\u63CF\u4E8C\u7EF4\u7801\uFF08${expireIn}\u79D2\u540E\u8FC7\u671F\uFF09...`);
-  const deadline = Date.now() + Math.min(expireIn, timeoutSec) * 1e3;
-  const result = await pollRegistration(domain, deviceCode, interval, deadline, log, options.signal);
-  if (result) {
-    log(`\u2705 \u6CE8\u518C\u6210\u529F\uFF01App ID: ${result.appId}`);
-  } else {
-    log("\u23F0 \u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
-  }
-  return result;
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// src/channels/wechat.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-function sleep2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var ILINK_BASE_URL = "https://ilinkai.weixin.qq.com";
-var ILINK_APP_CLIENT_VERSION = 2 << 16 | 2 << 8 | 0;
-var EP_GET_BOT_QR = "ilink/bot/get_bot_qrcode";
-var EP_GET_QR_STATUS = "ilink/bot/get_qrcode_status";
-var QR_TIMEOUT_MS = 15e3;
-async function wechatQrLogin(options) {
-  const botType = options?.botType || "3";
-  const timeoutSeconds = options?.timeoutSeconds || 480;
-  const stateDir = options?.stateDir || path.join(os.homedir?.() || "/tmp", ".engine7");
-  console.log("[wechat] Fetching QR code from iLink...");
-  let qrResp;
-  try {
-    qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
-  } catch (err) {
-    console.error(`[wechat] Failed to fetch QR code: ${err.message}`);
-    return null;
-  }
-  const qrcodeValue = String(qrResp?.qrcode || "");
-  const qrcodeUrl = String(qrResp?.qrcode_img_content || "");
-  if (!qrcodeValue) {
-    console.error("[wechat] QR response missing qrcode field");
-    return null;
-  }
-  const qrScanData = qrcodeUrl || qrcodeValue;
-  console.log("\n========== \u5FAE\u4FE1\u626B\u7801\u767B\u5F55 ==========");
-  if (qrcodeUrl) {
-    console.log(`\u626B\u7801\u94FE\u63A5: ${qrcodeUrl}`);
-  }
-  console.log("\u8BF7\u7528\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801\uFF08\u6216\u6253\u5F00\u4E0A\u9762\u7684\u94FE\u63A5\uFF09:");
-  console.log("===================================\n");
-  const deadline = Date.now() + timeoutSeconds * 1e3;
-  let currentBaseUrl = ILINK_BASE_URL;
-  let refreshCount = 0;
-  while (Date.now() < deadline) {
-    let statusResp;
-    try {
-      statusResp = await apiGet(currentBaseUrl, `${EP_GET_QR_STATUS}?qrcode=${qrcodeValue}`, "", QR_TIMEOUT_MS);
-    } catch {
-      await sleep2(1e3);
-      continue;
-    }
-    const status = String(statusResp?.status || "wait");
-    if (status === "wait") {
-      process.stdout.write(".");
-    } else if (status === "scaned") {
-      console.log("\n\u5DF2\u626B\u7801\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u91CC\u786E\u8BA4...");
-    } else if (status === "scaned_but_redirect") {
-      const redirectHost = String(statusResp?.redirect_host || "");
-      if (redirectHost) currentBaseUrl = `https://${redirectHost}`;
-    } else if (status === "expired") {
-      refreshCount++;
-      if (refreshCount > 3) {
-        console.log("\n\u4E8C\u7EF4\u7801\u591A\u6B21\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u767B\u5F55\u3002");
-        return null;
-      }
-      console.log(`
-\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u5237\u65B0\u4E2D... (${refreshCount}/3)`);
-      try {
-        qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
-        const newQrValue = String(qrResp?.qrcode || "");
-        const newQrUrl = String(qrResp?.qrcode_img_content || "");
-        if (newQrUrl) console.log(`\u65B0\u626B\u7801\u94FE\u63A5: ${newQrUrl}`);
-      } catch (err) {
-        console.error(`[wechat] QR refresh failed: ${err.message}`);
-        return null;
-      }
-    } else if (status === "confirmed") {
-      const accountId = String(statusResp?.ilink_bot_id || "");
-      const token = String(statusResp?.bot_token || "");
-      const baseUrl = String(statusResp?.baseurl || ILINK_BASE_URL);
-      const userId = String(statusResp?.ilink_user_id || "");
-      if (!accountId || !token) {
-        console.error("[wechat] QR confirmed but credential payload incomplete");
-        return null;
-      }
-      if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
-      const credFile = path.join(stateDir, `weixin-${accountId}.json`);
-      fs.writeFileSync(credFile, JSON.stringify({ accountId, token, baseUrl, userId }, null, 2), "utf8");
-      console.log(`
-\u2705 \u5FAE\u4FE1\u767B\u5F55\u6210\u529F!`);
-      console.log(`   accountId: ${accountId}`);
-      console.log(`   \u51ED\u8BC1\u5DF2\u4FDD\u5B58: ${credFile}`);
-      console.log(`
-\u8BF7\u5C06\u4EE5\u4E0B\u914D\u7F6E\u6DFB\u52A0\u5230 xiaoke.json:`);
-      console.log(JSON.stringify({
-        wechat: {
-          token,
-          accountId,
-          baseUrl: baseUrl !== ILINK_BASE_URL ? baseUrl : void 0
-        }
-      }, null, 2));
-      return { accountId, token, baseUrl, userId };
+  try {
+    const releaseBody = Object.entries(manifest).map(([k, v]) => `- **${k}**: ${typeof v === "object" ? JSON.stringify(v) : v}`).join("\n");
+    const createRes = await fetch(`https://api.github.com/repos/${repo}/releases`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${cfg.githubToken}`,
+        "Accept": "application/vnd.github+json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        tag_name: tag,
+        name: `${agentName} ${version}`,
+        body: releaseBody,
+        prerelease: false,
+        make_latest: "true"
+      })
+    });
+    if (!createRes.ok) {
+      const err = await createRes.text();
+      throw new Error(`\u521B\u5EFA release \u5931\u8D25: ${createRes.status} ${err}`);
     }
-    await sleep2(1e3);
+    const release = await createRes.json();
+    const uploadUrl = release.upload_url.replace("{?name,label}", "");
+    const fileBuffer = fs2.readFileSync(archiveFile);
+    const fileName = path2.basename(archiveFile);
+    const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${cfg.githubToken}`,
+        "Accept": "application/vnd.github+json",
+        "Content-Type": "application/gzip",
+        "Content-Length": String(fileBuffer.length)
+      },
+      body: fileBuffer
+    });
+    if (!uploadRes.ok) {
+      const err = await uploadRes.text();
+      throw new Error(`\u4E0A\u4F20 asset \u5931\u8D25: ${uploadRes.status} ${err}`);
+    }
+    console.log(`\u2705 \u4E0A\u4F20\u6210\u529F!`);
+    console.log(`   release: ${release.html_url}`);
+  } catch (e) {
+    console.error(`\u274C GitHub \u4E0A\u4F20\u5931\u8D25: ${e.message}`);
+    console.error(`   archive \u4ECD\u5728: ${archiveFile}`);
+    throw e;
   }
-  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);
+    fs2.rmSync(path2.dirname(archiveFile), { recursive: true, force: true });
+  } catch {
   }
 }
-
-// src/qr-render.ts
-import { createRequire } from "node:module";
-var require2 = createRequire(import.meta.url);
-async function renderQrTerminal(url, options) {
-  return new Promise((resolve2, reject) => {
-    try {
-      const qt = require2("qrcode-terminal");
-      qt.generate(url, { small: options?.small ?? true }, (output) => {
-        resolve2(output);
-      });
-    } catch (err) {
-      reject(err);
+async function downloadFromGitHub(cfg, agentName, version, destDir) {
+  const repo = `${cfg.githubOwner}/${cfg.repoName}`;
+  const tag = version || await getLatestReleaseTag(cfg, agentName);
+  console.log(`\u2B07\uFE0F  \u4E0B\u8F7D: ${repo} release ${tag}`);
+  const res = await fetch(`https://api.github.com/repos/${repo}/releases/tags/${tag}`, {
+    headers: {
+      "Authorization": `Bearer ${cfg.githubToken}`,
+      "Accept": "application/vnd.github+json"
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`\u83B7\u53D6 release \u5931\u8D25: ${res.status}`);
+  }
+  const release = await res.json();
+  const asset = release.assets?.find((a) => a.name.endsWith(".tar.gz") || a.name.endsWith(".zip"));
+  if (!asset) {
+    throw new Error(`release ${tag} \u6CA1\u6709 tar.gz/zip asset`);
+  }
+  const downloadRes = await fetch(asset.url, {
+    headers: {
+      "Authorization": `Bearer ${cfg.githubToken}`,
+      "Accept": "application/octet-stream"
+    }
+  });
+  if (!downloadRes.ok) {
+    throw new Error(`\u4E0B\u8F7D asset \u5931\u8D25: ${downloadRes.status}`);
+  }
+  const buffer = Buffer.from(await downloadRes.arrayBuffer());
+  const archiveFile = path2.join(destDir, asset.name);
+  fs2.writeFileSync(archiveFile, buffer);
+  return archiveFile;
+}
+async function getLatestReleaseTag(cfg, agentName) {
+  const repo = `${cfg.githubOwner}/${cfg.repoName}`;
+  const res = await fetch(`https://api.github.com/repos/${repo}/releases?per_page=30`, {
+    headers: {
+      "Authorization": `Bearer ${cfg.githubToken}`,
+      "Accept": "application/vnd.github+json"
     }
   });
+  if (!res.ok) {
+    throw new Error(`\u83B7\u53D6 release \u5217\u8868\u5931\u8D25: ${res.status}`);
+  }
+  const releases = await res.json();
+  const match = releases.find((r) => r.tag_name?.startsWith(`${agentName}-`));
+  if (!match) {
+    throw new Error(`\u6CA1\u6709\u627E\u5230 ${agentName} \u7684 release`);
+  }
+  return match.tag_name;
 }
+var CONFIG_PATH, PATH_PLACEHOLDERS, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL, WORKSPACE_EXCLUDE, TEXT_EXTENSIONS;
+var init_cli_travel = __esm({
+  "src/cli-travel.ts"() {
+    "use strict";
+    CONFIG_PATH = path2.join(os2.homedir(), ".engine7-travel.json");
+    PATH_PLACEHOLDERS = [
+      { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
+      { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
+      { placeholder: "{{STATE_DIR}}", getOriginal: (d) => d.stateDir }
+    ];
+    WORKSPACE_INCLUDE = /* @__PURE__ */ new Set([
+      // 核心文件
+      "AGENTS.md",
+      "SOUL.md",
+      "MEMORY.md",
+      "USER.md",
+      "HEARTBEAT.md",
+      "INDEX.md",
+      "SESSION-STATE.md",
+      // 核心目录
+      "prompts",
+      "topics",
+      "memory",
+      "inner-voice",
+      "docs",
+      "skills",
+      "voice-chat",
+      "scripts",
+      "selfie",
+      "moodboard",
+      // 状态文件 + 目录
+      ".calendar",
+      "nudge-state.json"
+    ]);
+    WORKSPACE_OPTIONAL = /* @__PURE__ */ new Set([
+      "images",
+      "tools"
+    ]);
+    WORKSPACE_EXCLUDE = /* @__PURE__ */ new Set([
+      "livestream",
+      "content-library",
+      "tmp",
+      ".git",
+      "node_modules",
+      "memory_runs",
+      "workspace",
+      "prompt-archive",
+      "aim-archive",
+      "test-agent",
+      "nul",
+      "*.bak*",
+      "*.bak-*",
+      "~$*"
+    ]);
+    TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".md",
+      ".json",
+      ".txt",
+      ".js",
+      ".ts",
+      ".mjs",
+      ".py",
+      ".yaml",
+      ".yml",
+      ".cmd",
+      ".bat",
+      ".sh",
+      ".csv",
+      ".html",
+      ".toml",
+      ".list"
+      // .everos 的 everos.toml/config.toml/ome.toml/everos-env.list
+    ]);
+  }
+});
 
 // src/cli-init.ts
+init_feishu_quick_register();
+init_wechat();
+init_qr_render();
+import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path3.dirname(__filename);
 var SCHEMA_VERSION = 1;
@@ -920,6 +1764,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 reconfig <\u76EE\u6807> [\u9009\u9879]           \u91CD\u65B0\u914D\u7F6E\u5DF2\u88C5\u7684 agent\uFF08wechat/feishu/discord/llm/channels\uFF09
   engine7 start [--config <path>]          \u542F\u52A8 Engine
   engine7 restart [--config <path>]        \u91CD\u542F Engine\uFF08\u6740\u65E7\u8FDB\u7A0B+\u542F\u52A8\uFF09
   engine7 service install|uninstall|status \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
@@ -1445,6 +2290,168 @@ async function main() {
     printHelp();
     process.exit(0);
   }
+  if (subcommand === "reconfig" || subcommand === "addchannel") {
+    const isLegacyAddchannel = subcommand === "addchannel";
+    let target = args[1] || "";
+    if (isLegacyAddchannel) target = target || "wechat";
+    const channel = target;
+    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 (!target && !isLegacyAddchannel) {
+      console.log("\u{1F527} engine7 reconfig \u2014 \u91CD\u65B0\u914D\u7F6E\u5DF2\u88C5\u7684 agent");
+      console.log("  \u7528\u6CD5: engine7 reconfig <\u76EE\u6807>");
+      console.log("");
+      console.log("  \u901A\u9053\u7C7B:");
+      console.log("    wechat    \u5FAE\u4FE1\u626B\u7801\u63A5\u5165\uFF08iLink\uFF0C1v1 \u79C1\u804A\uFF09");
+      console.log("    feishu    \u98DE\u4E66\u626B\u7801\u63A5\u5165\uFF08OAuth\uFF0C30\u79D2\uFF09");
+      console.log("    discord   Discord bot \u914D\u7F6E");
+      console.log("  \u6A21\u578B\u7C7B:");
+      console.log("    llm       \u66F4\u6362 LLM provider / API key / \u7AEF\u70B9");
+      console.log("  \u5176\u4ED6:");
+      console.log("    channels  \u67E5\u770B\u5F53\u524D\u901A\u9053\u72B6\u6001");
+      console.log("");
+      console.log("  \u9009\u9879: --state-dir <path>  --config <file>");
+      process.exit(0);
+    }
+    if (channel === "channels") {
+      const configsDir = path3.join(stateDir, "configs");
+      if (fs3.existsSync(configsDir)) {
+        const files = fs3.readdirSync(configsDir).filter((f) => f.endsWith(".json"));
+        for (const f of files) {
+          try {
+            const j = JSON.parse(fs3.readFileSync(path3.join(configsDir, f), "utf8"));
+            if (!j.channels) continue;
+            console.log(`
+\u{1F4C4} ${f}:`);
+            for (const [name, conf] of Object.entries(j.channels)) {
+              const c = conf;
+              console.log(`  ${c.enabled ? "\u2705" : "\u26D4"} ${name}${c.appId ? " (" + c.appId + ")" : ""}${c.accountId ? " (" + c.accountId + ")" : ""}`);
+            }
+          } catch {
+          }
+        }
+      } else {
+        console.log(`\u26A0\uFE0F \u672A\u627E\u5230 configs \u76EE\u5F55: ${configsDir}`);
+      }
+      process.exit(0);
+    }
+    if (channel === "llm") {
+      console.log("\u{1F527} LLM \u91CD\u914D\uFF08\u5F00\u53D1\u4E2D\uFF0Cv7.2 \u8BA1\u5212\uFF09");
+      console.log("   \u76EE\u524D\u8BF7\u624B\u52A8\u6539 config \u7684 models.providers \u6BB5");
+      process.exit(0);
+    }
+    if (channel === "discord") {
+      console.log("\u{1F527} Discord \u91CD\u914D\uFF08\u5F00\u53D1\u4E2D\uFF09");
+      console.log("   \u76EE\u524D\u8BF7\u624B\u52A8\u6539 config \u7684 channels.discord \u6BB5\uFF08token/userId\uFF09");
+      process.exit(0);
+    }
+    if (channel === "feishu") {
+      console.log("\u{1F527} \u98DE\u4E66\u626B\u7801\u63A5\u5165...");
+      const { registerFeishuApp: registerFeishuApp2 } = await Promise.resolve().then(() => (init_feishu_quick_register(), feishu_quick_register_exports));
+      const { renderQrTerminal: renderQrTerminal2 } = await Promise.resolve().then(() => (init_qr_render(), qr_render_exports));
+      const result = await registerFeishuApp2({
+        onLog: (msg) => console.log(`  ${msg}`),
+        onQrCode: async (url) => {
+          try {
+            console.log(await renderQrTerminal2(url, { small: true }));
+          } catch {
+            console.log(`
+  \u6D4F\u89C8\u5668\u6253\u5F00\u626B\u7801: ${url}
+`);
+          }
+        }
+      });
+      if (!result) {
+        console.error("\u274C \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25");
+        process.exit(1);
+      }
+      const configsDir2 = path3.join(stateDir, "configs");
+      let configFile2 = configName ? path3.join(configsDir2, configName) : "";
+      if (!configFile2 || !fs3.existsSync(configFile2)) {
+        if (fs3.existsSync(configsDir2)) {
+          for (const f of fs3.readdirSync(configsDir2).filter((f2) => f2.endsWith(".json"))) {
+            const full = path3.join(configsDir2, f);
+            try {
+              if (JSON.parse(fs3.readFileSync(full, "utf8")).channels) {
+                configFile2 = full;
+                break;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      if (configFile2 && fs3.existsSync(configFile2)) {
+        const j = JSON.parse(fs3.readFileSync(configFile2, "utf8"));
+        j.channels = j.channels || {};
+        j.channels.feishu = { enabled: true, appId: result.appId, appSecret: result.appSecret, connectionMode: "websocket", dmPolicy: "pairing", groupPolicy: "open" };
+        fs3.writeFileSync(configFile2, JSON.stringify(j, null, 2), "utf8");
+        console.log("\u2705 \u98DE\u4E66\u901A\u9053\u5DF2\u5199\u5165: " + configFile2);
+        console.log("\u91CD\u542F\u751F\u6548: engine7 restart");
+      } else {
+        console.log("\u26A0\uFE0F \u6CA1\u627E\u5230 config\uFF0C\u624B\u52A8\u52A0\uFF1A");
+        console.log(JSON.stringify({ feishu: { enabled: true, appId: result.appId, appSecret: result.appSecret, connectionMode: "websocket", dmPolicy: "pairing", groupPolicy: "open" } }, null, 2));
+      }
+      process.exit(0);
+    }
+    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\u76EE\u6807: ${channel || "(\u7A7A)"}\u3002\u652F\u6301: wechat / feishu / discord / llm / channels`);
+    console.error("\u7528\u6CD5: engine7 reconfig <\u76EE\u6807> [--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 = "";