@modelzen/feishu-codex-bridge 0.6.6 → 0.6.7-test.0

package/dist/cli.js

@@ -8509,7 +8509,7 @@ function withCodexHooksFeature(text) {
 }
 
 // src/service/update.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname9, join as join15, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
@@ -8523,7 +8523,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/service/common.ts
 init_paths();
-import { createReadStream, statSync as statSync2 } from "fs";
+import { appendFileSync, createReadStream, statSync as statSync2 } from "fs";
 import { appendFile, mkdir as mkdir7, readFile as readFile9 } from "fs/promises";
 import { dirname as dirname6, join as join11, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -8538,6 +8538,13 @@ async function ensureLogFiles() {
   await appendFile(serviceStdoutPath(), "");
   await appendFile(serviceStderrPath(), "");
 }
+function appendServiceErr(tag, line) {
+  try {
+    appendFileSync(serviceStderrPath(), `[${(/* @__PURE__ */ new Date()).toISOString()}] [${tag}] ${line}
+`);
+  } catch {
+  }
+}
 function resolveCliBinPath() {
   const distDir = dirname6(fileURLToPath2(import.meta.url));
   return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
@@ -8747,9 +8754,10 @@ function launchctlError(command, result) {
 // src/service/win-startup.ts
 init_paths();
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { openSync, readFileSync as readFileSync3, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync7, openSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync } from "fs";
 import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
 import { join as join13 } from "path";
+var RELAUNCH_TASK_NAME = "feishu-codex-bridge-relaunch";
 var RUN_KEY_PATH = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
 var RUN_KEY_NAME = "feishu-codex-bridge";
 var SERVICE_ENV_FLAG = "FEISHU_CODEX_BRIDGE_SERVICE";
@@ -8779,14 +8787,16 @@ function buildLauncherVbs() {
     ""
   ].join("\r\n");
 }
-function startNow() {
+function startNow(envPath) {
   const out = openSync(serviceStdoutPath(), "a");
   const err = openSync(serviceStderrPath(), "a");
+  const overrides = { [SERVICE_ENV_FLAG]: "1" };
+  if (envPath) overrides.PATH = envPath;
   const child = spawn3(process.execPath, [resolveCliBinPath(), "run"], {
     detached: true,
     windowsHide: true,
     stdio: ["ignore", out, err],
-    env: mergeProcessEnv(process.env, { [SERVICE_ENV_FLAG]: "1" })
+    env: mergeProcessEnv(process.env, overrides)
   });
   if (child.pid) writeFileSync(servicePidFile(), String(child.pid), "utf8");
   child.unref();
@@ -8817,10 +8827,150 @@ async function restartWinStartup() {
     throw new Error("\u767B\u5F55\u81EA\u542F\u672A\u5B89\u88C5\uFF08\u5148\u8FD0\u884C `feishu-codex-bridge start`\uFF09\u3002");
   }
   await ensureLogFiles();
-  killService();
-  startNow();
+  const oldPid = readServicePid();
+  if (oldPid === null || !pidAlive(oldPid)) {
+    startNow();
+    return statusWinStartup();
+  }
+  writeRelaunchRequest({ oldPid, envPath: process.env.PATH ?? "", nonce: `${process.pid}-${Date.now()}` });
+  if (!spawnTreeFreeRelauncher()) {
+    clearRelaunchRequest();
+    appendServiceErr("relaunch", `no tree-free backend (powershell/schtasks); kept old pid=${oldPid} running, did NOT restart`);
+    throw new Error("\u65E0\u6CD5\u62C9\u8D77\u300C\u6811\u5916\u300D\u91CD\u542F\u8FDB\u7A0B\uFF08powershell \u4E0E schtasks \u5747\u4E0D\u53EF\u7528\uFF09\uFF1B\u5DF2\u4FDD\u7559\u65E7\u670D\u52A1\u7EE7\u7EED\u8FD0\u884C\uFF0C\u672A\u91CD\u542F\u3002");
+  }
+  appendServiceErr("relaunch", `submitted async relaunch for oldPid=${oldPid}`);
   return statusWinStartup();
 }
+function relaunchRequestFile() {
+  return join13(paths.appDir, "relaunch.json");
+}
+function writeRelaunchRequest(req) {
+  writeFileSync(relaunchRequestFile(), JSON.stringify(req), "utf8");
+}
+function clearRelaunchRequest() {
+  rmSync(relaunchRequestFile(), { force: true });
+}
+function relaunchClaimFile() {
+  return `${relaunchRequestFile()}.claim.${process.pid}`;
+}
+function claimRelaunchRequest() {
+  const claim = relaunchClaimFile();
+  try {
+    renameSync(relaunchRequestFile(), claim);
+  } catch {
+    return null;
+  }
+  try {
+    const r = JSON.parse(readFileSync3(claim, "utf8"));
+    if (typeof r.oldPid === "number" && Number.isFinite(r.oldPid)) {
+      return {
+        oldPid: r.oldPid,
+        envPath: typeof r.envPath === "string" ? r.envPath : "",
+        nonce: String(r.nonce ?? "")
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function clearRelaunchClaim() {
+  rmSync(relaunchClaimFile(), { force: true });
+}
+function buildRelauncherPowershell(binPath = resolveCliBinPath(), nodePath = process.execPath) {
+  const inner = `"${nodePath}" "${binPath}" __win-relaunch`;
+  const lit = `'${inner.replace(/'/g, "''")}'`;
+  return `$c=${lit}; try { Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine=$c } -ErrorAction Stop | Out-Null } catch { schtasks /create /tn ${RELAUNCH_TASK_NAME} /tr $c /sc ONCE /st 00:00 /f | Out-Null; schtasks /run /tn ${RELAUNCH_TASK_NAME} | Out-Null }`;
+}
+function powershellPath() {
+  const root = process.env.SystemRoot || process.env.windir || "C:\\Windows";
+  const p = join13(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return existsSync7(p) ? p : null;
+}
+function spawnTreeFreeRelauncher() {
+  const ps = powershellPath();
+  if (ps) {
+    const errFd = openSync(serviceStderrPath(), "a");
+    const child = spawn3(
+      ps,
+      ["-NoProfile", "-NonInteractive", "-WindowStyle", "Hidden", "-Command", buildRelauncherPowershell()],
+      { detached: true, windowsHide: true, stdio: ["ignore", errFd, errFd] }
+    );
+    child.on("error", (e) => appendServiceErr("relaunch", `powershell spawn error: ${e.message}`));
+    child.unref();
+    return true;
+  }
+  appendServiceErr("relaunch", "powershell.exe not found; trying schtasks fallback");
+  return spawnSchtasksRelauncher();
+}
+function spawnSchtasksRelauncher() {
+  const tr = `"${process.execPath}" "${resolveCliBinPath()}" __win-relaunch`;
+  const create = spawnSync2(
+    "schtasks",
+    ["/create", "/tn", RELAUNCH_TASK_NAME, "/tr", tr, "/sc", "ONCE", "/st", "00:00", "/f"],
+    { encoding: "utf8", windowsHide: true }
+  );
+  if (create.status !== 0) {
+    appendServiceErr("relaunch", `schtasks /create failed exit=${create.status ?? "?"} ${(create.stderr || "").trim()}`);
+    return false;
+  }
+  const run = spawnSync2("schtasks", ["/run", "/tn", RELAUNCH_TASK_NAME], { encoding: "utf8", windowsHide: true });
+  if (run.status !== 0) {
+    appendServiceErr("relaunch", `schtasks /run failed exit=${run.status ?? "?"} ${(run.stderr || "").trim()}`);
+    return false;
+  }
+  return true;
+}
+function defaultTaskkill(pid) {
+  const r = spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
+  return { status: r.status, stderr: (r.stderr || "").toString() };
+}
+async function runWinRelaunch(deps = {}) {
+  const claim = deps.claimRequest ?? claimRelaunchRequest;
+  const clearClaim = deps.clearRequest ?? clearRelaunchClaim;
+  const alive = deps.pidAlive ?? pidAlive;
+  const kill = deps.taskkill ?? defaultTaskkill;
+  const start = deps.start ?? startNow;
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const graceMs = deps.graceMs ?? 15e3;
+  const pollMs = deps.pollMs ?? 200;
+  const now = deps.now ?? (() => Date.now());
+  const ensureLogs = deps.ensureLogs ?? ensureLogFiles;
+  const logLine = deps.logLine ?? ((line) => appendServiceErr("relaunch", line));
+  await ensureLogs();
+  const req = claim();
+  if (!req) {
+    logLine("no relaunch request to claim (already handled by another relauncher, or none)");
+    return;
+  }
+  try {
+    logLine(`start oldPid=${req.oldPid} self=${process.pid}`);
+    if (alive(req.oldPid)) {
+      const r = kill(req.oldPid);
+      logLine(`taskkill oldPid=${req.oldPid} exit=${r.status ?? "?"} ${r.stderr.trim()}`.trim());
+    }
+    const deadline = now() + graceMs;
+    while (now() < deadline && alive(req.oldPid)) {
+      await sleep(pollMs);
+    }
+    if (alive(req.oldPid)) {
+      logLine(
+        `ABORT: oldPid=${req.oldPid} still alive after ${graceMs}ms (elevated / access denied?); not starting new to avoid double instance`
+      );
+      return;
+    }
+    await sleep(300);
+    start(req.envPath);
+    logLine(`relaunched; new service.pid=${readServicePid() ?? "?"}`);
+  } finally {
+    clearClaim();
+    if (process.platform === "win32") {
+      try {
+        spawnSync2("schtasks", ["/delete", "/tn", RELAUNCH_TASK_NAME, "/f"], { stdio: "ignore", windowsHide: true });
+      } catch {
+      }
+    }
+  }
+}
 function statusWinStartup() {
   const installed = isInstalled();
   const pid = readServicePid();
@@ -8880,12 +9030,15 @@ function pidAlive(pid) {
 function killService() {
   const pid = readServicePid();
   if (pid === null || !pidAlive(pid)) return;
-  spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+  const r = spawnSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
+  if (r.status !== 0) {
+    appendServiceErr("kill", `taskkill pid=${pid} exit=${r.status ?? "?"} ${(r.stderr || "").toString().trim()}`);
+  }
 }
 
 // src/service/systemd.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { mkdir as mkdir10, rm as rm4, writeFile as writeFile9 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname8, join as join14 } from "path";
@@ -8989,7 +9142,7 @@ function statusSystemd() {
   };
 }
 function unitExists() {
-  return existsSync7(systemdUnitPath());
+  return existsSync8(systemdUnitPath());
 }
 function systemdActive() {
   const r = spawnSync3("systemctl", ["--user", "is-active", SYSTEMD_UNIT_NAME], {
@@ -9064,7 +9217,7 @@ function packageName() {
   return pkgJson().name ?? "@modelzen/feishu-codex-bridge";
 }
 function isDevSource() {
-  return existsSync8(join15(pkgRoot(), ".git"));
+  return existsSync9(join15(pkgRoot(), ".git"));
 }
 function isNewer(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -9779,7 +9932,7 @@ init_paths();
 init_paths();
 init_logger();
 import { mkdir as mkdir11 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { isAbsolute as isAbsolute2, join as join17, resolve as resolve7 } from "path";
 
 // src/project/announcement.ts
@@ -9972,7 +10125,7 @@ function assertBackendUsable(backend, mode) {
 async function resolveCwd(name, existingPath) {
   if (existingPath) {
     const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve7(existingPath);
-    if (!existsSync9(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
+    if (!existsSync10(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
     return { cwd: cwd2, blank: false };
   }
   const cwd = join17(paths.projectsRootDir, name);
@@ -14737,16 +14890,22 @@ async function doUpdate() {
   }
   const res = await installLatest();
   log.info("daemon-control", "update-installed", { ok: res.ok });
-  if (!res.ok) return;
+  appendServiceErr("daemon-control", `update-installed ok=${res.ok}`);
+  if (!res.ok) {
+    appendServiceErr("daemon-control", "install failed \u2014 keeping old version, not restarting");
+    return;
+  }
   await doRestart("update");
 }
 async function doRestart(phase) {
   if (!isServiceRunning()) {
     log.info("daemon-control", "restart-skipped-no-service", { phase });
+    appendServiceErr("daemon-control", `restart-skipped-no-service (phase=${phase}); service.pid \u672A\u6307\u5411\u5728\u8DD1\u7684 daemon`);
     return;
   }
   await getServiceAdapter().restart();
   log.info("daemon-control", "restart-issued", { phase });
+  appendServiceErr("daemon-control", `restart-issued (phase=${phase})`);
 }
 
 // src/web/mount.ts
@@ -15495,6 +15654,9 @@ ${UI_PURE_JS}
   var daemon = null;         // /api/daemon
   var diag = null;           // /api/diagnosis \u7ED3\u679C\uFF08\u5F53\u524D bot \u7684\u63A2\u6D4B\uFF1B\u5207 Tab \u5FC5\u6E05\uFF09
   var catalog = null;        // /api/backends \u7F13\u5B58\uFF08\u540E\u7AEF\u7BA1\u7406\u5361 + \u9879\u76EE picker \u590D\u7528\uFF09
+  var lastUpdate = null;     // /api/update/check \u7ED3\u679C\u7F13\u5B58\uFF1A\u603B\u89C8 5s \u91CD\u6E32\u4E0D\u91CD\u67E5\uFF08\u6BCF\u6B21\u67E5\u90FD spawn npm view\uFF09
+  var updateCheckedAt = 0;   // \u4E0A\u6B21\u68C0\u67E5\u65F6\u95F4\u6233\uFF1B\u62FF\u5230\u7ED3\u679C\u8D85 30min\u3001\u8F6F\u5931\u8D25\u8D85 ~2min \u624D\u968F\u91CD\u6E32\u81EA\u52A8\u590D\u67E5
+  var updateChecking = false;// in-flight \u95F8\uFF1Anpm view \u53EF\u80FD\u6570\u79D2~20s\uFF0C\u671F\u95F4 5s \u91CD\u6E32\u4E0D\u53E0\u53D1\u7B2C\u4E8C\u4E2A\u8BF7\u6C42
   var drawerProject = null;  // \u62BD\u5C49\u91CC\u6253\u5F00\u7684\u9879\u76EE\u540D
   var diagBotId = null;      // diag \u5C5E\u4E8E\u54EA\u4E2A bot\uFF08\u9632\u4E32\u53F0\uFF09
   var bkDetailId = null;     // \u540E\u7AEF Agent \u8BE6\u60C5\u89C6\u56FE\u5F53\u524D\u5C55\u5F00\u7684\u540E\u7AEF id\uFF08null=\u5217\u8868\uFF09
@@ -15693,6 +15855,14 @@ ${UI_PURE_JS}
     fetch('/api/daemon').then(function (r) { return r.json(); })
       .then(function (d) {
         daemon = d;
+        // \u8FD0\u884C\u4E2D\u7684\u5B9E\u9645\u7248\u672C\u4E00\u65E6\u8DDF\u7248\u672C\u68C0\u67E5\u7F13\u5B58\u91CC\u7684 current \u5BF9\u4E0D\u4E0A\uFF08\u591A\u534A\u662F\u521A\u66F4\u65B0+\u91CD\u542F\u5B8C\u6210\uFF09\uFF0C
+        // \u5C31\u4F5C\u5E9F\u7F13\u5B58\u5E76\u5F53\u573A\u8865\u67E5\u4E00\u6B21\uFF08\u82E5\u5728\u603B\u89C8\u9875\uFF09\uFF0C\u628A\u300C\u6709\u65B0\u7248\u300D\u7ACB\u523B\u7FFB\u6210\u300C\u5DF2\u662F\u6700\u65B0\u7248\u300D\u2014\u2014\u4E0D\u7B49
+        // \u4E0B\u4E00\u8F6E renderRoute\uFF0C\u6D88\u9664 loadState/loadDaemon \u540C\u5468\u671F\u7ADE\u6001\u5BFC\u81F4\u7684 ~10s \u5EF6\u8FDF\u4E0E\u6A2A\u5E45\u6B8B\u7559\u3002
+        // \u53EA\u5728\u7248\u672C\u771F\u53D8\u65F6\u624D\u67E5\uFF08\u7A33\u6001 d.version===current\uFF09\uFF0C\u65E2\u7559\u4F4F\u66F4\u65B0\u540E\u7684\u5373\u65F6\u53CD\u9988\uFF0C\u53C8\u4E0D\u56DE\u5230 5s \u7A7A\u8F6C\u3002
+        if (lastUpdate && d.version && d.version !== lastUpdate.current) {
+          lastUpdate = null; updateCheckedAt = 0;
+          if (parseRoute(location.hash).tab === 'overview') { var ub = $('updateBody'); if (ub) loadUpdate(ub); }
+        }
         if (parseRoute(location.hash).tab === 'overview') { var b = $('daemonBody'); if (b) renderDaemon(b); }
         renderSidebarFoot();
         renderGlobalSummary();
@@ -16006,7 +16176,14 @@ ${UI_PURE_JS}
     daemonCard.appendChild(updateBody);
     root.appendChild(daemonCard);
     renderDaemon(daemonBody);
-    loadUpdate(updateBody);
+    // \u7248\u672C\u68C0\u67E5\u4F1A\u5728\u670D\u52A1\u7AEF spawn\u300Cnpm view\u300D\uFF0C\u4E0D\u80FD\u8DDF\u7740 5s \u91CD\u6E32\u6BCF\u6B21\u90FD\u8DD1\uFF1A\u6709\u7F13\u5B58\u5C31\u76F4\u63A5\u6E32\uFF0C
+    // \u53EA\u5728\u9996\u6B21\u6216\u7F13\u5B58\u8FC7\u671F\uFF0830min\uFF09\u65F6\u624D\u771F\u67E5\u4E00\u6B21\u3002\u624B\u52A8\u300C\u68C0\u67E5\u66F4\u65B0\u300D\u6309\u94AE\u4ECD\u5F3A\u5236\u5237\u65B0\u3002
+    if (lastUpdate) {
+      renderUpdate(updateBody, lastUpdate);
+      if (Date.now() - updateCheckedAt > 30 * 60 * 1000) loadUpdate(updateBody);
+    } else {
+      loadUpdate(updateBody);
+    }
 
     // \u{1F916} \u673A\u5668\u4EBA\uFF08\u5728 Feishu Bridge \u5361\u4E0B\u9762\uFF0C\u5404\u81EA\u5360\u6EE1\u5BBD\u5EA6\uFF09
     var botsCard = el('div', 'card');
@@ -16365,9 +16542,19 @@ ${UI_PURE_JS}
   }
 
   function loadUpdate(box) {
+    if (updateChecking) return;          // \u5728\u9014\u5C31\u4E0D\u53E0\u53D1\uFF1A\u6162\u68C0\u67E5\uFF08npm view \u6700\u957F 20s\uFF09\u671F\u95F4 5s \u91CD\u6E32\u4E0D\u91CD\u590D spawn
+    updateChecking = true;
+    updateCheckedAt = Date.now();        // \u4E50\u89C2\u5360\u4F4D\uFF1Ain-flight \u671F\u95F4 30min \u8FB9\u754C\u4E0D\u518D\u88AB\u53CD\u590D\u5224\u771F
     fetch('/api/update/check').then(function (r) { return r.json(); })
-      .then(function (u) { renderUpdate(box, u); })
-      .catch(function () { box.textContent = '\u26A0\uFE0F \u7248\u672C\u68C0\u67E5\u5931\u8D25\uFF08\u7F51\u7EDC\u6216 npm registry\uFF09'; });
+      .then(function (u) {
+        lastUpdate = u;
+        // \u8F6F\u5931\u8D25\uFF1A\u975E dev \u5374\u6CA1\u62FF\u5230 latest\uFF08\u591A\u534A registry \u4E0D\u53EF\u8FBE/\u8D85\u65F6\uFF0C\u670D\u52A1\u7AEF\u4ECD\u56DE 200\uFF09\uFF0C\u53EA\u7F13\u5B58 ~2min
+        // \u4FBF\u81EA\u52A8\u590D\u67E5\uFF0C\u522B\u628A\u300C\u67E5\u8BE2\u5931\u8D25\u300D\u9489\u4F4F 30min\uFF1B\u62FF\u5230 latest \u6216 dev \u6A21\u5F0F\u624D\u6309\u5B8C\u6574 30min TTL\u3002
+        updateCheckedAt = (u && (u.dev || u.latest)) ? Date.now() : Date.now() - 28 * 60 * 1000;
+        renderUpdate(box, u);
+      })
+      .catch(function () { box.textContent = '\u26A0\uFE0F \u7248\u672C\u68C0\u67E5\u5931\u8D25\uFF08\u7F51\u7EDC\u6216 npm registry\uFF09'; })
+      .then(function () { updateChecking = false; });  // finally\uFF1A\u65E0\u8BBA\u6210\u8D25\u90FD\u677E\u95F8
   }
   function renderUpdate(box, u) {
     box.textContent = '';
@@ -18141,6 +18328,7 @@ async function runSupervisor(bots) {
   const supervisorStartedAt = Date.now();
   const cliEntry = process.argv[1];
   if (!cliEntry) throw new Error("supervisor: \u65E0\u6CD5\u89E3\u6790 CLI \u5165\u53E3\uFF08process.argv[1] \u4E3A\u7A7A\uFF09");
+  recordServicePid();
   const childEnv = { ...process.env };
   delete childEnv[SERVICE_ENV_FLAG];
   let shuttingDown = false;
@@ -18407,6 +18595,7 @@ async function runOnboardingConsole() {
     releaseLock = acquireSingleInstanceLock("__onboarding__");
   } catch (err) {
     if (err instanceof BridgeAlreadyRunningError) {
+      clearServicePid();
       console.error(`\u2717 ${err.message}`);
       process.exitCode = 1;
       return;
@@ -18475,6 +18664,7 @@ async function runSingle(botName) {
     releaseLock = acquireSingleInstanceLock(cfg.accounts.app.id);
   } catch (err) {
     if (err instanceof BridgeAlreadyRunningError) {
+      clearServicePid();
       console.error(`\u2717 ${err.message}`);
       log.info("run", "already-running", { pid: err.pid });
       process.exitCode = 1;
@@ -19030,6 +19220,9 @@ program.command("web").description("\u672C\u673A Web \u63A7\u5236\u53F0\uFF08\u5
 program.command("__daemon-control <action>", { hidden: true }).action(async (action) => {
   await runDaemonControl(action);
 });
+program.command("__win-relaunch", { hidden: true }).action(async () => {
+  await runWinRelaunch();
+});
 var bot = program.command("bot").description("\u98DE\u4E66\u673A\u5668\u4EBA\u7BA1\u7406\uFF08\u591A\u673A\u5668\u4EBA\uFF09");
 bot.command("init [name]").description("\u6CE8\u518C\u4E00\u4E2A\u98DE\u4E66\u673A\u5668\u4EBA\u5E76\u6388\u6743\uFF08\u53EF\u9009\u77ED\u540D\uFF09").action(async (name) => {
   await runBotInit(name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelzen/feishu-codex-bridge",
-  "version": "0.6.6",
+  "version": "0.6.7-test.0",
   "description": "Bridge Feishu/Lark messenger with local Codex via app-server (project=group, thread=session)",
   "type": "module",
   "bin": {