@modelzen/feishu-codex-bridge 0.2.1-win → 0.2.2-win

package/dist/cli.js

@@ -2013,8 +2013,8 @@ function card(elements, opts = {}) {
   if (opts.streaming) {
     config.streaming_mode = true;
     config.streaming_config = {
-      print_frequency_ms: { default: 70 },
-      print_step: { default: 1 },
+      print_frequency_ms: { default: 25 },
+      print_step: { default: 6 },
       print_strategy: "fast"
     };
   }
@@ -2036,6 +2036,9 @@ function card(elements, opts = {}) {
 function md(content) {
   return { tag: "markdown", content };
 }
+function mdStream(content, elementId) {
+  return { tag: "markdown", element_id: elementId, content };
+}
 function image(imgKey, alt = "") {
   return {
     tag: "img",
@@ -2585,6 +2588,7 @@ function escapeInline2(s) {
 var RC = {
   stop: "run.stop"
 };
+var ANSWER_EID = "answer";
 var REASONING_MAX = 1500;
 var COLLAPSE_TOOL_THRESHOLD = 3;
 var PROCESS_BODY_BUDGET = 22e3;
@@ -2598,14 +2602,19 @@ function renderRunning(state, rc) {
   const elements = [];
   const reasoning = reasoningContent(state);
   if (reasoning) elements.push(reasoningPanel(reasoning, state.reasoningActive));
-  const blocks = rc.showTools === false ? state.blocks.filter((b) => b.kind !== "tool") : state.blocks;
-  for (const group of groupBlocks(blocks)) {
-    if (group.kind === "text") {
-      if (group.content.trim()) elements.push(md(group.content));
-    } else {
-      elements.push(...renderToolGroup(group.tools, false));
+  const showTools = rc.showTools !== false;
+  const tools = [];
+  const textParts = [];
+  for (const b of state.blocks) {
+    if (b.kind === "tool") {
+      if (showTools) tools.push(b.tool);
+    } else if (b.content.trim()) {
+      textParts.push(b.content);
     }
   }
+  if (tools.length > 0) elements.push(...renderToolGroup(tools, false));
+  const answer = textParts.join("\n\n");
+  if (answer) elements.push(mdStream(answer, ANSWER_EID));
   if (state.footer) elements.push(footerStatus(state.footer));
   if (rc.cardKey) elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
   return elements;
@@ -2752,16 +2761,105 @@ function truncate4(s, n) {
 }
 
 // src/card/run-card-stream.ts
-var STREAM_THROTTLE_MS = 250;
+var STREAM_THROTTLE_MS = 150;
 var RunCardStream = class {
   cardId = "";
   _messageId = "";
   seq = 0;
   lastPush = 0;
   lastContent = "";
+  // Per-turn push counters — surfaced via stats() for the stream.timing log.
+  pushCount = 0;
+  cardPushes = 0;
+  // whole-card card.update (structure)
+  elPushes = 0;
+  // element cardElement.content (answer typewriter)
+  totalRttMs = 0;
+  maxRttMs = 0;
+  // Coalesced streaming. The consume loop records the latest {card, answerEid} in
+  // `pending`; a single pump() drains it — NON-BLOCKING, so consuming codex events
+  // never stalls on a round-trip (awaiting each push serially drained the backlog
+  // at one event per ~RTT → "已回完、飞书还在慢慢打字"). The pump pushes only the most
+  // recent snapshot per round-trip: when only the answer text grew it streams that
+  // via cardElement.content (typewriter), otherwise it whole-card updates.
+  pending = null;
+  pumpChannel = null;
+  pumpPromise = null;
+  // Baselines for the pump's route decision (structure unchanged + answer grew?).
+  lastStructureSig = "";
+  lastAnswerText = "";
   get messageId() {
     return this._messageId;
   }
+  /** Push counts (whole-card vs element) + round-trip stats for this card. */
+  stats() {
+    return {
+      pushCount: this.pushCount,
+      cardPushes: this.cardPushes,
+      elPushes: this.elPushes,
+      totalRttMs: this.totalRttMs,
+      maxRttMs: this.maxRttMs
+    };
+  }
+  /**
+   * Record the latest card and ensure the pump is running. Returns immediately;
+   * calls that arrive while a push is in flight collapse into a single push of
+   * the most recent card once that round-trip completes. Use this from the
+   * event-consume loop instead of awaiting {@link streamCard} per event.
+   */
+  streamCoalesced(channel, fullCard, answerEid) {
+    this.pending = { card: fullCard, answerEid };
+    this.pumpChannel = channel;
+    if (!this.pumpPromise) this.pumpPromise = this.pump();
+  }
+  /** Await any in-flight coalesced push so the final streaming frame lands (and
+   * `seq` stays ordered) before the terminal update. Call after the loop ends. */
+  async drain() {
+    if (this.pumpPromise) await this.pumpPromise;
+  }
+  async pump() {
+    try {
+      while (this.pending && this.pumpChannel) {
+        const { card: card2, answerEid } = this.pending;
+        this.pending = null;
+        const t0 = Date.now();
+        const answer = answerEid ? answerContent(card2, answerEid) : null;
+        const sig = structureSig(card2, answerEid);
+        if (answerEid && answer !== null && sig === this.lastStructureSig && answer !== this.lastAnswerText && answer.startsWith(this.lastAnswerText)) {
+          await this.streamElement(this.pumpChannel, answerEid, answer);
+          this.lastAnswerText = answer;
+        } else {
+          await this.streamCard(this.pumpChannel, card2, true);
+          this.lastStructureSig = sig;
+          this.lastAnswerText = answer ?? "";
+        }
+        const gap = STREAM_THROTTLE_MS - (Date.now() - t0);
+        if (this.pending && gap > 0) await new Promise((r) => setTimeout(r, gap));
+      }
+    } finally {
+      this.pumpPromise = null;
+    }
+  }
+  /** Element-level streaming push (cardkit.v1.cardElement.content): the answer
+   * element's accumulated full text. Feishu diffs the prefix and types the delta
+   * per the card's streaming_config. Needs streaming_mode on the card. */
+  async streamElement(channel, elementId, content) {
+    if (!this.cardId) return;
+    const t0 = Date.now();
+    try {
+      await channel.rawClient.cardkit.v1.cardElement.content({
+        path: { card_id: this.cardId, element_id: elementId },
+        data: { content, sequence: ++this.seq, uuid: `e_${this.cardId}_${this.seq}` }
+      });
+      const rtt = Date.now() - t0;
+      this.pushCount++;
+      this.elPushes++;
+      this.totalRttMs += rtt;
+      if (rtt > this.maxRttMs) this.maxRttMs = rtt;
+    } catch (err) {
+      log.fail("card", err, { phase: "run-stream-el", cardId: this.cardId, seq: this.seq });
+    }
+  }
   /** Create the entity from the initial (running) card and send a message
    * referencing it by card_id. Returns the carrier message id. */
   async create(channel, chatId, initialCard, opts) {
@@ -2803,11 +2901,17 @@ var RunCardStream = class {
     if (!force && now - this.lastPush < STREAM_THROTTLE_MS) return;
     this.lastPush = now;
     this.lastContent = data;
+    const t0 = Date.now();
     try {
       await channel.rawClient.cardkit.v1.card.update({
         path: { card_id: this.cardId },
         data: { card: { type: "card_json", data }, sequence: ++this.seq, uuid: `s_${this.cardId}_${this.seq}` }
       });
+      const rtt = Date.now() - t0;
+      this.pushCount++;
+      this.cardPushes++;
+      this.totalRttMs += rtt;
+      if (rtt > this.maxRttMs) this.maxRttMs = rtt;
     } catch (err) {
       log.fail("card", err, { phase: "run-stream", cardId: this.cardId, seq: this.seq });
     }
@@ -2837,6 +2941,21 @@ var RunCardStream = class {
     }
   }
 };
+function answerContent(card2, eid) {
+  const els = card2.body?.elements;
+  if (!Array.isArray(els)) return null;
+  for (const el of els) {
+    if (el && el.element_id === eid) return typeof el.content === "string" ? el.content : "";
+  }
+  return null;
+}
+function structureSig(card2, eid) {
+  const body = card2.body;
+  const els = body?.elements;
+  if (!eid || !Array.isArray(els)) return JSON.stringify(card2);
+  const blanked = els.map((el) => el && el.element_id === eid ? { ...el, content: "" } : el);
+  return JSON.stringify({ ...card2, body: { ...body, elements: blanked } });
+}
 
 // src/card/outbound-images.ts
 import { readFile as readFile5, stat as stat2 } from "fs/promises";
@@ -3438,8 +3557,8 @@ function buildGroupSettingsCard(project) {
 
 // src/service/update.ts
 import { execFile, spawn as spawn4 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname8, join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname10, join as join11, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { promisify } from "util";
 
@@ -3448,12 +3567,14 @@ import { spawn as spawn3, spawnSync } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir6, rm as rm2, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir3, userInfo as userInfo2 } from "os";
-import { dirname as dirname6, join as join8, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname7, join as join8, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/service/common.ts
-import { appendFile, mkdir as mkdir5 } from "fs/promises";
-import { join as join7 } from "path";
+import { createReadStream, statSync } from "fs";
+import { appendFile, mkdir as mkdir5, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname6, join as join7, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function serviceStdoutPath() {
   return join7(paths.appDir, "service.log");
 }
@@ -3465,22 +3586,76 @@ async function ensureLogFiles() {
   await appendFile(serviceStdoutPath(), "");
   await appendFile(serviceStderrPath(), "");
 }
+function resolveCliBinPath() {
+  const distDir = dirname6(fileURLToPath2(import.meta.url));
+  return resolve3(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+}
+async function tailServiceLogs(follow) {
+  await ensureLogFiles();
+  const files = [serviceStdoutPath(), serviceStderrPath()];
+  for (const f of files) {
+    const tail = await lastLines(f, 100);
+    if (tail) process.stdout.write(`
+===== ${f} =====
+${tail}
+`);
+  }
+  if (!follow) return;
+  const offsets = new Map(files.map((f) => [f, fileSize(f)]));
+  await new Promise((resolvePromise) => {
+    const onSigint = () => {
+      clearInterval(timer);
+      process.off("SIGINT", onSigint);
+      resolvePromise();
+    };
+    process.on("SIGINT", onSigint);
+    const timer = setInterval(() => {
+      for (const f of files) {
+        const size = fileSize(f);
+        const from = offsets.get(f) ?? 0;
+        if (size > from) {
+          offsets.set(f, size);
+          createReadStream(f, { start: from, end: size - 1, encoding: "utf8" }).pipe(process.stdout, {
+            end: false
+          });
+        } else if (size < from) {
+          offsets.set(f, size);
+        }
+      }
+    }, 700);
+  });
+}
+function fileSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+async function lastLines(file, n) {
+  try {
+    const text = await readFile7(file, "utf8");
+    return text.split("\n").slice(-n - 1).join("\n").trimEnd();
+  } catch {
+    return "";
+  }
+}
 
 // src/service/launchd.ts
 var LAUNCHD_LABEL = "ai.feishu-codex-bridge.bot";
 function launchAgentPlistPath() {
   return join8(homedir3(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
-function resolveCliBinPath() {
-  const distDir = dirname6(fileURLToPath2(import.meta.url));
-  return resolve3(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+function resolveCliBinPath2() {
+  const distDir = dirname7(fileURLToPath3(import.meta.url));
+  return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
 }
 function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function buildPlist() {
   const nodePath = process.execPath;
-  const cliBinPath = resolveCliBinPath();
+  const cliBinPath = resolveCliBinPath2();
   const pathEnv = process.env.PATH ?? "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin";
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -3513,7 +3688,7 @@ function buildPlist() {
 }
 async function installLaunchd() {
   const plistPath = launchAgentPlistPath();
-  await mkdir6(dirname6(plistPath), { recursive: true });
+  await mkdir6(dirname7(plistPath), { recursive: true });
   await ensureLogFiles();
   await writeFile5(plistPath, buildPlist(), "utf8");
   if (isLoaded()) {
@@ -3619,21 +3794,16 @@ function launchctlError(command, result) {
 
 // src/service/schtasks.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { createReadStream, existsSync as existsSync5, statSync } from "fs";
-import { mkdir as mkdir7, readFile as readFile7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname7, join as join9, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join9 } from "path";
 var WINDOWS_TASK_NAME = "feishu-codex-bridge";
 function launcherCmdPath() {
   return join9(paths.appDir, "service-launcher.cmd");
 }
-function resolveCliBinPath2() {
-  const distDir = dirname7(fileURLToPath3(import.meta.url));
-  return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
-}
 function buildLauncherCmd() {
   const nodePath = process.execPath;
-  const cliBinPath = resolveCliBinPath2();
+  const cliBinPath = resolveCliBinPath();
   const pathEnv = process.env.PATH ?? "";
   return [
     "@echo off",
@@ -3657,7 +3827,7 @@ function schtasksError(command, r) {
 }
 async function writeLauncherCmd() {
   const cmdPath = launcherCmdPath();
-  await mkdir7(dirname7(cmdPath), { recursive: true });
+  await mkdir7(dirname8(cmdPath), { recursive: true });
   await ensureLogFiles();
   await writeFile6(cmdPath, buildLauncherCmd(), "utf8");
 }
@@ -3735,56 +3905,124 @@ async function waitUntilStopped(timeoutMs = 5e3) {
   }
   return false;
 }
-async function tailSchtaskLogs(follow) {
+
+// src/service/systemd.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir8, rm as rm4, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname9, join as join10 } from "path";
+var SYSTEMD_UNIT_NAME = "feishu-codex-bridge.service";
+function systemdUnitPath() {
+  const base = process.env.XDG_CONFIG_HOME ?? join10(homedir4(), ".config");
+  return join10(base, "systemd", "user", SYSTEMD_UNIT_NAME);
+}
+function buildUnit() {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const nodePath = process.execPath;
+  const cliBinPath = resolveCliBinPath();
+  const pathEnv = process.env.PATH ?? "";
+  return `[Unit]
+Description=feishu-codex-bridge bot
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart="${esc(nodePath)}" "${esc(cliBinPath)}" run
+Restart=always
+RestartSec=5
+StandardOutput=append:${serviceStdoutPath()}
+StandardError=append:${serviceStderrPath()}
+Environment="PATH=${esc(pathEnv)}"
+
+[Install]
+WantedBy=default.target
+`;
+}
+function runSystemctl(args) {
+  const r = spawnSync3("systemctl", ["--user", ...args], { encoding: "utf8" });
+  return {
+    ok: r.status === 0,
+    status: r.status,
+    stdout: r.stdout ?? "",
+    stderr: (r.error ? `${r.error.message}
+` : "") + (r.stderr ?? "")
+  };
+}
+function systemctlError(command, r) {
+  const out = [r.stderr.trim(), r.stdout.trim()].filter(Boolean).join("\n");
+  return new Error(`${command} \u5931\u8D25\uFF08exit ${r.status ?? "unknown"}\uFF09${out ? `\uFF1A${out}` : ""}`);
+}
+function systemdAvailable() {
+  const r = spawnSync3("systemctl", ["--user", "is-system-running"], { encoding: "utf8" });
+  if (r.error) return false;
+  const out = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+  return !/not been booted with systemd|Failed to connect to (the )?bus|Failed to (connect|get) D-?Bus/i.test(out);
+}
+function ensureSystemdOrThrow() {
+  if (systemdAvailable()) return;
+  throw new Error(
+    "\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u7684\u7528\u6237\u7EA7 systemd\u3002WSL \u9700\u5728 /etc/wsl.conf \u5199\u5165 `[boot]\\nsystemd=true` \u540E\u6267\u884C `wsl --shutdown` \u91CD\u542F\uFF1B\u6216\u76F4\u63A5\u7528 `feishu-codex-bridge run` \u524D\u53F0\u8FD0\u884C\uFF08\u65E0\u9700\u540E\u53F0\u670D\u52A1\uFF09\u3002"
+  );
+}
+async function installSystemd() {
+  ensureSystemdOrThrow();
+  const unitPath = systemdUnitPath();
+  await mkdir8(dirname9(unitPath), { recursive: true });
   await ensureLogFiles();
-  const files = [serviceStdoutPath(), serviceStderrPath()];
-  for (const f of files) {
-    const tail = await lastLines(f, 100);
-    if (tail) process.stdout.write(`
-===== ${f} =====
-${tail}
-`);
-  }
-  if (!follow) return;
-  const offsets = new Map(files.map((f) => [f, fileSize(f)]));
-  await new Promise((resolvePromise) => {
-    const onSigint = () => {
-      clearInterval(timer);
-      process.off("SIGINT", onSigint);
-      resolvePromise();
-    };
-    process.on("SIGINT", onSigint);
-    const timer = setInterval(() => {
-      for (const f of files) {
-        const size = fileSize(f);
-        const from = offsets.get(f) ?? 0;
-        if (size > from) {
-          offsets.set(f, size);
-          createReadStream(f, { start: from, end: size - 1, encoding: "utf8" }).pipe(process.stdout, {
-            end: false
-          });
-        } else if (size < from) {
-          offsets.set(f, size);
-        }
-      }
-    }, 700);
-  });
+  await writeFile7(unitPath, buildUnit(), "utf8");
+  const reload = runSystemctl(["daemon-reload"]);
+  if (!reload.ok) throw systemctlError("systemctl --user daemon-reload", reload);
+  const enable = runSystemctl(["enable", "--now", SYSTEMD_UNIT_NAME]);
+  if (!enable.ok) throw systemctlError("systemctl --user enable --now", enable);
+  return statusSystemd();
+}
+async function uninstallSystemd() {
+  if (systemdAvailable() && unitExists()) {
+    runSystemctl(["disable", "--now", SYSTEMD_UNIT_NAME]);
+  }
+  await rm4(systemdUnitPath(), { force: true });
+  if (systemdAvailable()) runSystemctl(["daemon-reload"]);
+}
+async function restartSystemd() {
+  ensureSystemdOrThrow();
+  if (!unitExists()) {
+    throw new Error(`systemd unit \u672A\u5B89\u88C5\uFF1A${systemdUnitPath()}\uFF08\u5148\u8FD0\u884C \`feishu-codex-bridge start\`\uFF09`);
+  }
+  const restart = runSystemctl(["restart", SYSTEMD_UNIT_NAME]);
+  if (!restart.ok) throw systemctlError("systemctl --user restart", restart);
+  return statusSystemd();
+}
+function statusSystemd() {
+  const installed = unitExists();
+  const raw = installed && systemdAvailable() ? describeService() : "";
+  return {
+    platformName: "systemd (Linux user)",
+    installed,
+    running: systemdActive(),
+    servicePath: systemdUnitPath(),
+    stdoutPath: serviceStdoutPath(),
+    stderrPath: serviceStderrPath(),
+    pid: raw.match(/Main PID:\s*(\d+)/)?.[1],
+    // On an inactive unit the "Process: <pid> ExecStart=... status=<n>" line
+    // carries the last exit code.
+    lastExit: raw.match(/Process:\s+\d+\s+ExecStart=.*status=(\d+)/)?.[1],
+    raw
+  };
 }
-function fileSize(file) {
-  try {
-    return statSync(file).size;
-  } catch {
-    return 0;
-  }
+function unitExists() {
+  return existsSync6(systemdUnitPath());
 }
-async function lastLines(file, n) {
-  try {
-    const text = await readFile7(file, "utf8");
-    const lines = text.split("\n");
-    return lines.slice(-n - 1).join("\n").trimEnd();
-  } catch {
-    return "";
-  }
+function systemdActive() {
+  const r = spawnSync3("systemctl", ["--user", "is-active", SYSTEMD_UNIT_NAME], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  return r.status === 0;
+}
+function describeService() {
+  const r = runSystemctl(["status", SYSTEMD_UNIT_NAME, "--no-pager"]);
+  return r.stdout || r.stderr || "";
 }
 
 // src/service/adapter.ts
@@ -3804,17 +4042,27 @@ function getServiceAdapter() {
       uninstall: uninstallSchtask,
       status: async () => statusSchtask(),
       restart: restartSchtask,
-      logs: tailSchtaskLogs
+      logs: tailServiceLogs
+    };
+  }
+  if (process.platform === "linux") {
+    return {
+      install: installSystemd,
+      uninstall: uninstallSystemd,
+      status: async () => statusSystemd(),
+      restart: restartSystemd,
+      logs: tailServiceLogs
     };
   }
   throw new Error(
-    "service\uFF1A\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u540E\u53F0\u670D\u52A1\uFF08\u4EC5 macOS launchd / Windows \u8BA1\u5212\u4EFB\u52A1\uFF09\u3002\u8BF7\u7528 `feishu-codex-bridge run` \u524D\u53F0\u8FD0\u884C" + (process.platform === "linux" ? "\uFF1BLinux systemd \u652F\u6301\u540E\u7EED\u63D0\u4F9B\u3002" : "\u3002")
+    "service\uFF1A\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u540E\u53F0\u670D\u52A1\uFF08\u4EC5 macOS launchd / Windows \u8BA1\u5212\u4EFB\u52A1 / Linux systemd\uFF09\u3002\u8BF7\u7528 `feishu-codex-bridge run` \u524D\u53F0\u8FD0\u884C\u3002"
   );
 }
 function isServiceRunning() {
   try {
     if (process.platform === "darwin") return isLoaded();
     if (process.platform === "win32") return schtaskRunning();
+    if (process.platform === "linux") return systemdActive();
   } catch {
   }
   return false;
@@ -3824,11 +4072,11 @@ function isServiceRunning() {
 var execFileP = promisify(execFile);
 var NPM = process.platform === "win32" ? "npm.cmd" : "npm";
 function pkgRoot() {
-  return resolve5(dirname8(fileURLToPath4(import.meta.url)), "..");
+  return resolve5(dirname10(fileURLToPath4(import.meta.url)), "..");
 }
 function pkgJson() {
   try {
-    return JSON.parse(readFileSync2(join10(pkgRoot(), "package.json"), "utf8"));
+    return JSON.parse(readFileSync2(join11(pkgRoot(), "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -3840,7 +4088,7 @@ function packageName() {
   return pkgJson().name ?? "@modelzen/feishu-codex-bridge";
 }
 function isDevSource() {
-  return existsSync6(join10(pkgRoot(), ".git"));
+  return existsSync7(join11(pkgRoot(), ".git"));
 }
 function isNewer(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -3886,9 +4134,9 @@ async function restartDaemon() {
 }
 
 // src/project/lifecycle.ts
-import { mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { isAbsolute as isAbsolute2, join as join11, resolve as resolve6 } from "path";
+import { mkdir as mkdir9 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { isAbsolute as isAbsolute2, join as join12, resolve as resolve6 } from "path";
 
 // src/project/git-info.ts
 import { execFile as execFile2 } from "child_process";
@@ -4024,11 +4272,11 @@ async function onboardGroup(channel, project) {
 async function resolveCwd(name, existingPath) {
   if (existingPath) {
     const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve6(existingPath);
-    if (!existsSync7(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
+    if (!existsSync8(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
     return { cwd: cwd2, blank: false };
   }
-  const cwd = join11(paths.projectsRootDir, name);
-  await mkdir8(cwd, { recursive: true });
+  const cwd = join12(paths.projectsRootDir, name);
+  await mkdir9(cwd, { recursive: true });
   return { cwd, blank: true };
 }
 async function createProject(channel, input2) {
@@ -4095,8 +4343,8 @@ async function leaveChat(channel, chatId) {
 }
 
 // src/bot/session-store.ts
-import { mkdir as mkdir9, readFile as readFile8, rename as rename5, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { mkdir as mkdir10, readFile as readFile8, rename as rename5, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 var FILE_VERSION3 = 1;
 async function read2() {
   try {
@@ -4109,10 +4357,10 @@ async function read2() {
   }
 }
 async function write2(sessions) {
-  await mkdir9(dirname9(paths.sessionsFile), { recursive: true });
+  await mkdir10(dirname11(paths.sessionsFile), { recursive: true });
   const tmp = `${paths.sessionsFile}.tmp-${process.pid}`;
   const body = { version: FILE_VERSION3, sessions };
-  await writeFile7(tmp, `${JSON.stringify(body, null, 2)}
+  await writeFile8(tmp, `${JSON.stringify(body, null, 2)}
 `, "utf8");
   await rename5(tmp, paths.sessionsFile);
 }
@@ -4156,8 +4404,8 @@ async function handleDmConsole(channel, cfg, msg) {
 }
 
 // src/bot/media.ts
-import { mkdir as mkdir10, readdir as readdir2, rm as rm4, stat as stat3 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir11, readdir as readdir2, rm as rm5, stat as stat3 } from "fs/promises";
+import { join as join13 } from "path";
 var MAX_IMAGES2 = 9;
 var MEDIA_TTL_MS = 60 * 6e4;
 var EXT_BY_CONTENT_TYPE = {
@@ -4186,7 +4434,7 @@ async function collectInboundImages(channel, msg) {
   if (refs.length === 0) return [];
   await pruneOldMedia();
   try {
-    await mkdir10(paths.mediaDir, { recursive: true });
+    await mkdir11(paths.mediaDir, { recursive: true });
   } catch {
   }
   const out = [];
@@ -4262,7 +4510,7 @@ async function downloadOne(channel, ref, index) {
       params: { type: "image" }
     });
     const ext = extFromHeaders(res.headers);
-    const file = join12(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
+    const file = join13(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
     await res.writeFile(file);
     return file;
   } catch (err) {
@@ -4296,10 +4544,10 @@ async function pruneOldMedia() {
   }
   const cutoff = Date.now() - MEDIA_TTL_MS;
   for (const name of entries) {
-    const file = join12(paths.mediaDir, name);
+    const file = join13(paths.mediaDir, name);
     try {
       const st = await stat3(file);
-      if (st.mtimeMs < cutoff) await rm4(file, { force: true });
+      if (st.mtimeMs < cutoff) await rm5(file, { force: true });
     } catch {
     }
   }
@@ -5348,11 +5596,29 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           },
           stopSignal
         );
+        const tStart = Date.now();
+        let firstEvAt = 0;
+        let firstTextAt = 0;
+        let lastEvAt = tStart;
+        let evCount = 0;
+        let textChars = 0;
         for await (const ev of guarded) {
+          const tEv = Date.now();
+          if (!firstEvAt) firstEvAt = tEv;
+          const et = ev.type;
+          if (et === "text_delta") {
+            if (!firstTextAt) firstTextAt = tEv;
+            const d = ev.delta;
+            if (typeof d === "string") textChars += d.length;
+          }
+          lastEvAt = tEv;
+          evCount++;
           render.apply(ev);
           rc.rs = render.snapshot();
-          await stream2.streamCard(channel, buildRunCard(rc));
+          stream2.streamCoalesced(channel, buildRunCard(rc), ANSWER_EID);
         }
+        const doneAt = Date.now();
+        await stream2.drain();
         state.interrupt = void 0;
         const killed = interrupted || timedOut;
         if (timedOut) render.timeout(Math.max(1, Math.round(idleMs / 6e4)));
@@ -5373,6 +5639,25 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           rc.images = await uploadOutboundImages(channel, imgSources, opts.cwd ?? fallbackCwd);
         }
         await stream2.updateCard(channel, buildRunCard(rc));
+        {
+          const terminalAt = Date.now();
+          const st = stream2.stats();
+          log.info("stream", "timing", {
+            firstEv: firstEvAt ? firstEvAt - tStart : -1,
+            firstText: firstTextAt ? firstTextAt - tStart : -1,
+            lastEv: lastEvAt - tStart,
+            done: doneAt - tStart,
+            terminal: terminalAt - tStart,
+            doneToTerminal: terminalAt - doneAt,
+            events: evCount,
+            textChars,
+            pushes: st.pushCount,
+            cardPushes: st.cardPushes,
+            elPushes: st.elPushes,
+            rttAvg: st.pushCount ? Math.round(st.totalRttMs / st.pushCount) : 0,
+            rttMax: st.maxRttMs
+          });
+        }
         runsByCard.delete(cardMsgId);
         promoteCard(finalMsgId, rc);
         for (const fence of fences) {
@@ -5634,7 +5919,7 @@ async function startBridge(opts) {
 
 // src/core/single-instance.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "fs";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname12 } from "path";
 var BridgeAlreadyRunningError = class extends Error {
   constructor(pid) {
     super(
@@ -5663,7 +5948,7 @@ function acquireSingleInstanceLock(appId) {
   } catch (err) {
     if (err instanceof BridgeAlreadyRunningError) throw err;
   }
-  mkdirSync2(dirname10(file), { recursive: true });
+  mkdirSync2(dirname12(file), { recursive: true });
   const record = { pid: process.pid, appId, startedAt: Date.now() };
   writeFileSync(file, `${JSON.stringify(record)}
 `, "utf8");
@@ -5732,9 +6017,7 @@ async function runStart() {
     return;
   }
   const status = await getServiceAdapter().install();
-  console.log(
-    process.platform === "win32" ? "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u767B\u5F55\u81EA\u542F\uFF1B\u6CE8\u610F\uFF1AWindows \u8BA1\u5212\u4EFB\u52A1\u65E0\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002" : "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u5F00\u673A\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002"
-  );
+  console.log(installedNote());
   printStatus(status);
 }
 async function runStop() {
@@ -5752,6 +6035,16 @@ async function runStatus() {
 async function runLogs(follow) {
   await getServiceAdapter().logs(follow);
 }
+function installedNote() {
+  switch (process.platform) {
+    case "win32":
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u767B\u5F55\u81EA\u542F\uFF1B\u6CE8\u610F\uFF1AWindows \u8BA1\u5212\u4EFB\u52A1\u65E0\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002";
+    case "linux":
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u767B\u5F55\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002\n  \u63D0\u793A\uFF1A\u6CE8\u9500\u540E\u4ECD\u4FDD\u6301\u8FD0\u884C\u9700\u6267\u884C\u4E00\u6B21 `loginctl enable-linger $USER`\u3002";
+    default:
+      return "\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u5F00\u673A\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002";
+  }
+}
 function printStatus(status) {
   console.log(`service:   ${status.platformName}`);
   console.log(`path:      ${status.servicePath}`);
@@ -5817,7 +6110,7 @@ async function runUpdate(opts = {}) {
 }
 
 // src/cli/commands/bot.ts
-import { rm as rm5 } from "fs/promises";
+import { rm as rm6 } from "fs/promises";
 async function runBotInit(name) {
   if (!ensureCodex()) {
     process.exitCode = 1;
@@ -5872,7 +6165,7 @@ async function runBotRm(name) {
   }
   const after = await removeBot(bot2.appId);
   await removeSecret(secretKeyForApp(bot2.appId));
-  await rm5(botDir(bot2.appId), { recursive: true, force: true });
+  await rm6(botDir(bot2.appId), { recursive: true, force: true });
   console.log(`\u2713 \u5DF2\u79FB\u9664\u673A\u5668\u4EBA\u300C${bot2.name}\u300D(${bot2.appId})\uFF1A\u6CE8\u518C\u8868 + \u5BC6\u94A5 + \u72B6\u6001\u76EE\u5F55(projects/sessions)\u3002`);
   if (after.bots.length === 0) {
     console.log("  \u5DF2\u65E0\u4EFB\u4F55\u673A\u5668\u4EBA\uFF0C`bot init` \u91CD\u65B0\u521B\u5EFA\u3002");

package/package.json

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