lark-remote 0.5.18 → 0.5.20

package/dist/card/run-state.js

@@ -125,8 +125,6 @@ function reduceRunStateInner(state, event) {
 }
 /** Handle app-server turn_started — records the operation kind (turn vs compact). */
 function reduceTurnStartedEvent(state, event) {
-    if (event.type !== 'turn_started')
-        return state;
     return {
         ...state,
         operationKind: event.operationKind,
@@ -142,8 +140,6 @@ function reduceTurnStartedEvent(state, event) {
  * the active streaming content sits at the bottom, like the exec path.
  */
 function reduceTurnDiffEvent(state, event) {
-    if (event.type !== 'turn_diff')
-        return state;
     let next = state;
     const ts = event.timestamp;
     const complete = event.complete === true;
@@ -170,12 +166,7 @@ function reduceTurnDiffEvent(state, event) {
                 ...(complete ? { completedAt: ts } : {}),
             };
         }, !complete);
-        next = {
-            ...next,
-            blocks: keepLatestBlocks(capped),
-            omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-            footer: 'streaming',
-        };
+        next = withCappedBlocks(next, capped, 'streaming');
     }
     if (event.reasoning !== undefined) {
         const capped = upsertSnapshotBlock(next.blocks, (b) => b.kind === 'thinking' && b.itemId === event.itemId, () => ({
@@ -195,12 +186,7 @@ function reduceTurnDiffEvent(state, event) {
                 ...(complete ? { completedAt: ts } : {}),
             };
         }, !complete);
-        next = {
-            ...next,
-            blocks: keepLatestBlocks(capped),
-            omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-            footer: 'thinking',
-        };
+        next = withCappedBlocks(next, capped, 'thinking');
     }
     if (event.toolOutput !== undefined) {
         const capped = upsertSnapshotBlock(next.blocks, (b) => b.kind === 'tool' && b.tool.id === event.itemId, () => {
@@ -231,12 +217,7 @@ function reduceTurnDiffEvent(state, event) {
                 ...(complete ? { completedAt: ts } : {}),
             },
         }), !complete);
-        next = {
-            ...next,
-            blocks: keepLatestBlocks(capped),
-            omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-            footer: 'tool_running',
-        };
+        next = withCappedBlocks(next, capped, 'tool_running');
     }
     if (event.plan !== undefined) {
         const newPlan = keepTailMarked(event.plan, MAX_REASONING_CHARS * 2);
@@ -256,12 +237,7 @@ function reduceTurnDiffEvent(state, event) {
                 ...(complete ? { completedAt: ts } : {}),
             };
         }, !complete);
-        next = {
-            ...next,
-            plan: newPlan,
-            blocks: keepLatestBlocks(capped),
-            omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-        };
+        next = withCappedBlocks({ ...next, plan: newPlan }, capped);
     }
     if (event.fileChanges !== undefined) {
         let blocks = next.blocks;
@@ -278,12 +254,7 @@ function reduceTurnDiffEvent(state, event) {
             // 同一 item 的同一路径原地替换（权威 diff 校正），新路径/新 item 追加。
             blocks = upsertSnapshotBlock(blocks, (b) => b.kind === 'file_change' && b.itemId === event.itemId && b.path === fc.path, () => fileBlock, () => fileBlock, !complete);
         }
-        const capped = blocks;
-        next = {
-            ...next,
-            blocks: keepLatestBlocks(capped),
-            omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-        };
+        next = withCappedBlocks(next, blocks);
     }
     return next;
 }
@@ -313,8 +284,6 @@ function upsertSnapshotBlock(blocks, predicate, fallback, update, moveToEndWhenN
 }
 /** Handle system init and compact_boundary events. */
 function reduceSystemEvent(state, event) {
-    if (event.type !== 'system')
-        return state;
     if (event.subtype === 'init') {
         return { ...state, sessionId: event.session_id, model: event.model, footer: 'thinking' };
     }
@@ -336,8 +305,6 @@ function reduceSystemEvent(state, event) {
  *  - errorMsg: 首个非 undefined 胜出（agent 的更具体）
  */
 function reduceResultEvent(state, event) {
-    if (event.type !== 'result')
-        return state;
     // Pre-init result guard: Claude CLI --resume emits a historical result (from
     // the previous turn) before sending system.init for the new run. Without this
     // guard, that stale result would prematurely transition to 'finalizing',
@@ -375,8 +342,6 @@ function reduceResultEvent(state, event) {
 }
 /** Record an authoritative protocol final answer and remove its progress copy. */
 function reduceFinalAnswerEvent(state, event) {
-    if (event.type !== 'final_answer')
-        return state;
     if (!event.text.trim() && !state.finalAnswer)
         return state;
     const blocks = event.itemId
@@ -443,8 +408,6 @@ function promoteFinalAnswer(state, source, authoritativeText) {
  * 不再走事件（那时已经没有 run 在消费流了）。
  */
 function reduceBackgroundJobsEvent(state, event) {
-    if (event.type !== 'background_jobs')
-        return state;
     return { ...state, backgroundJobs: event.jobs };
 }
 /**
@@ -460,6 +423,95 @@ export function removeBackgroundJob(state, jobId) {
         backgroundJobs: (state.backgroundJobs ?? []).filter((job) => job.id !== jobId),
     };
 }
+/** 宿主仍在执行的任务状态词。状态缺失也算在跑——它还在名单上。 */
+const RUNNING_JOB_STATUSES = new Set(['running', 'stopping']);
+/**
+ * 该任务是否仍在跑（`ended` / `unknown` 都不算）。
+ *
+ * 卡片据此决定要不要渲染「⏹ 停止」：给已经结束的任务留一个点了必然失败的
+ * 按钮，等于逼用户拿「停止」当查询用。
+ */
+export function isLiveBackgroundJob(job) {
+    return job.status === undefined || RUNNING_JOB_STATUSES.has(job.status);
+}
+/** 宿主状态 → 桥侧状态：仍在跑的保留原词，其余已知终态归一成 `ended`。 */
+function bridgeJobStatus(status) {
+    return RUNNING_JOB_STATUSES.has(status) ? status : 'ended';
+}
+/**
+ * 收尾后把宿主推来的整份任务名单同步进终态卡状态。
+ *
+ * 与 reducer 的分工：reducer 处理的是"收尾那一刻的名单"，只在 run 还在消费
+ * 事件时有效；终态之后 `reduceRunState` 直接早退（终态幂等），名单只能由
+ * 这里更新。
+ *
+ * 三条规则：
+ * - 名单里消失 = 宿主已结算（`job/list` 是整份替换，摘掉即结束）→ `ended`；
+ * - 名单里还在、宿主却给了终态词 → `ended`（有些宿主会把已结束的行留在名单里）；
+ * - `ended` 是终态，不回退成 running —— 同一个 job id 不会重新开始跑。
+ *
+ * 无变化时返回**同一个 state 引用**：bridge 靠它跳过无谓的卡片 patch。
+ */
+export function syncBackgroundJobs(state, roster) {
+    const tracked = state.backgroundJobs ?? [];
+    const byId = new Map(roster.map((job) => [job.id, job]));
+    const next = tracked.map((job) => {
+        const row = byId.get(job.id);
+        if (!row)
+            return job.status === 'ended' ? job : { ...job, status: 'ended' };
+        if (job.status === 'ended')
+            return job;
+        const status = row.status === undefined ? job.status : bridgeJobStatus(row.status);
+        const label = row.label.trim() === '' ? job.label : row.label;
+        const progress = row.progress ?? job.progress;
+        if (status === job.status && label === job.label && progress === job.progress)
+            return job;
+        return {
+            ...job,
+            label,
+            ...(status === undefined ? {} : { status }),
+            ...(progress === undefined ? {} : { progress }),
+        };
+    });
+    // 新出现的任务只收仍在跑的：与收尾采集同一口径（列出已结束的任务只会被
+    // 读成"还在跑"）。
+    const seen = new Set(tracked.map((job) => job.id));
+    for (const row of roster) {
+        if (seen.has(row.id))
+            continue;
+        if (row.status !== undefined && !RUNNING_JOB_STATUSES.has(row.status))
+            continue;
+        next.push({
+            id: row.id,
+            label: row.label,
+            ...(row.status === undefined ? {} : { status: row.status }),
+            ...(row.progress === undefined ? {} : { progress: row.progress }),
+        });
+    }
+    if (next.length === tracked.length && next.every((job, index) => job === tracked[index])) {
+        return state;
+    }
+    return { ...state, backgroundJobs: next };
+}
+/**
+ * 订阅断了但任务仍未结算：把在跑的任务标成「状态未知」。
+ *
+ * 监控中断不等于任务结束——不标出来，卡片又会退化成"最后一次观测当现状"，
+ * 正是这次要修的那个缺陷。未知态仍保留停止按钮（用户还能尝试停掉）。
+ */
+export function markBackgroundJobsUnknown(state) {
+    const jobs = state.backgroundJobs;
+    if (!jobs || jobs.length === 0)
+        return state;
+    let changed = false;
+    const next = jobs.map((job) => {
+        if (!isLiveBackgroundJob(job))
+            return job;
+        changed = true;
+        return { ...job, status: 'unknown' };
+    });
+    return changed ? { ...state, backgroundJobs: next } : state;
+}
 /**
  * 运行期状态投影 → 状态行。
  *
@@ -467,8 +519,6 @@ export function removeBackgroundJob(state, jobId) {
  * 维度（上一步算出的上下文水位）擦掉。
  */
 function reduceRunStatusEvent(state, event) {
-    if (event.type !== 'run_status')
-        return state;
     const prev = state.liveStatus ?? {};
     const live = {
         ...prev,
@@ -486,8 +536,6 @@ function reduceRunStatusEvent(state, event) {
 }
 /** Handle assistant thinking/text/tool_use content blocks. */
 function reduceAssistantEvent(state, event) {
-    if (event.type !== 'assistant')
-        return state;
     let next = state;
     for (const content of event.message.content) {
         if (content.type === 'thinking') {
@@ -516,12 +564,7 @@ function reduceAssistantEvent(state, event) {
                         timestamp: event.timestamp,
                     },
                 ];
-            next = {
-                ...next,
-                blocks: keepLatestBlocks(newBlocks),
-                omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, newBlocks.length - MAX_BLOCKS),
-                footer: 'thinking',
-            };
+            next = withCappedBlocks(next, newBlocks, 'thinking');
         }
         else if (content.type === 'text') {
             const blocks = markThinkingInactive(next.blocks);
@@ -545,12 +588,7 @@ function reduceAssistantEvent(state, event) {
                         timestamp: event.timestamp,
                     },
                 ];
-            next = {
-                ...next,
-                blocks: keepLatestBlocks(newBlocks),
-                omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, newBlocks.length - MAX_BLOCKS),
-                footer: 'streaming',
-            };
+            next = withCappedBlocks(next, newBlocks, 'streaming');
         }
         else {
             // parse the truncated stored string ONCE here (not on every render)
@@ -585,12 +623,7 @@ function reduceAssistantEvent(state, event) {
             }
             else {
                 const capped = [...blocks, { kind: 'tool', tool: incomingTool }];
-                next = {
-                    ...next,
-                    blocks: keepLatestBlocks(capped),
-                    omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-                    footer: 'tool_running',
-                };
+                next = withCappedBlocks(next, capped, 'tool_running');
             }
         }
     }
@@ -627,8 +660,6 @@ function mergeToolUse(existing, incoming) {
  *  advances to 'streaming' on every content block (parity with old behavior);
  *  only the blocks array is preserved by reference when nothing matches. */
 function reduceToolResultEvent(state, event) {
-    if (event.type !== 'user')
-        return state;
     let next = state;
     for (const content of event.message.content) {
         const targetId = content.tool_use_id;
@@ -656,8 +687,6 @@ function reduceToolResultEvent(state, event) {
 }
 /** Handle notice event — append a runtime notice (warning / reroute / compaction). */
 function reduceNoticeEvent(state, event) {
-    if (event.type !== 'notice')
-        return state;
     return {
         ...state,
         notices: [
@@ -673,8 +702,6 @@ function reduceNoticeEvent(state, event) {
 }
 /** Handle session_info event — update sessionTitle / mode only when present. */
 function reduceSessionInfoEvent(state, event) {
-    if (event.type !== 'session_info')
-        return state;
     return {
         ...state,
         ...(event.title !== undefined ? { sessionTitle: event.title } : {}),
@@ -683,8 +710,6 @@ function reduceSessionInfoEvent(state, event) {
 }
 /** Handle plan event — accumulate plan text for Codex-style agents. */
 function reducePlanEvent(state, event) {
-    if (event.type !== 'plan')
-        return state;
     const currentPlan = state.plan ?? '';
     const newPlan = keepTailMarked(currentPlan + '\n' + event.plan, MAX_REASONING_CHARS * 2);
     // Plan is a single evolving document — replace the existing plan block
@@ -694,17 +719,10 @@ function reducePlanEvent(state, event) {
         ...withoutOldPlan,
         { kind: 'plan', content: newPlan, active: true, timestamp: event.timestamp },
     ];
-    return {
-        ...state,
-        plan: newPlan,
-        blocks: keepLatestBlocks(newBlocks),
-        omittedBlocks: (state.omittedBlocks ?? 0) + Math.max(0, newBlocks.length - MAX_BLOCKS),
-    };
+    return withCappedBlocks({ ...state, plan: newPlan }, newBlocks);
 }
 /** Handle file_change event — emit a file_change block for rendering (Codex-style agents). */
 function reduceFileChangeEvent(state, event) {
-    if (event.type !== 'file_change')
-        return state;
     // Add file_change block for rendering (collapsed by default)
     const newBlocks = [
         ...state.blocks,
@@ -716,11 +734,7 @@ function reduceFileChangeEvent(state, event) {
             timestamp: event.timestamp,
         },
     ];
-    return {
-        ...state,
-        blocks: keepLatestBlocks(newBlocks),
-        omittedBlocks: (state.omittedBlocks ?? 0) + Math.max(0, newBlocks.length - MAX_BLOCKS),
-    };
+    return withCappedBlocks(state, newBlocks);
 }
 export function finishRun(state, terminal, meta = {}) {
     const withFinalAnswer = promoteFinalAnswer(state, 'inferred');
@@ -773,14 +787,27 @@ function stringifyUnknown(value) {
     try {
         // JSON.stringify(undefined) returns the value undefined, which would
         // violate this function's string contract and crash callers that take
-        // .length on the result (2026-08-17 kimi ACP tool_call without rawInput
-        // → truncateDetail TypeError). Normalize to ''.
+        // .length on the result. Normalize to ''.
         return JSON.stringify(value) ?? '';
     }
     catch {
         return String(value);
     }
 }
+/**
+ * 尾块统一收口：keepLatestBlocks 截断 + omittedBlocks 计数 + footer 更新一步
+ * 完成。所有「追加/更新块后只保留最新 MAX_BLOCKS 块」的事件归约共用（此前
+ * 多处逐字重复）；`blocks` 必须传截断前的数组，被丢出的最旧块才会计入
+ * omittedBlocks。`footer` 不传时保持原值（plan/file_change 归约不改 footer）。
+ */
+function withCappedBlocks(next, blocks, footer) {
+    return {
+        ...next,
+        blocks: keepLatestBlocks(blocks),
+        omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, blocks.length - MAX_BLOCKS),
+        ...(footer === undefined ? {} : { footer }),
+    };
+}
 function keepLatestBlocks(blocks) {
     return blocks.length <= MAX_BLOCKS ? blocks : blocks.slice(-MAX_BLOCKS);
 }
@@ -790,8 +817,8 @@ const TRUNCATION_MARKER_RE = /^…（前 (\d+) 字符已省略）\n/;
  * 给「已经不再是最新」的 text 块补上 `MAX_TEXT_CHARS` 存储窗口。
  *
  * 为什么最新一条不截：它就是卡片上的**输出**，终态还会被 `promoteFinalAnswer`
- * 提成最终回答。提前按窗口切掉头部，渲染层再怎么回答优先也补不回来（2026-11-01
- * 输出块被截断缺陷：16074 字符的回答只进到渲染层 12000 字符，且是从中间开始的）。
+ * 提成最终回答。提前按窗口切掉头部，渲染层再怎么回答优先也补不回来
+ * （16074 字符的回答只进到渲染层 12000 字符，且是从中间开始的）。
  *
  * 为什么其余 text 块仍然截：它们只是进度信息，卡片本来就只会展示最新几步；
  * 存储层必须保持有界（`MAX_BLOCKS` × 窗口），否则长 run 的内存随历史线性增长。
@@ -826,7 +853,7 @@ function capStaleTextBlocks(blocks) {
  * keepTail + 截断标记：被去头的存储内容以前缀如实标注（信息保真红线：禁止静默丢弃）。
  * 标记计入 maxChars 预算（存储总量仍 ≤ maxChars，保持既有长度不变量）。
  *
- * 计数口径（2026-10 修正）：只统计**真实丢弃的正文**，不含标记自身开销。
+ * 计数口径：只统计**真实丢弃的正文**，不含标记自身开销。
  * 关键点是增量流下 `value` 往往已带上一次的标记（`marker + kept`）；若直接
  * 用 `value.length - kept.length` 计费，会把上一帧的标记文本也算进「已省略」，
  * 造成每帧显示十几字符的虚高。这里先剥离旧标记，把 N 定义为**从该块起始累计

package/dist/card/tool-render.d.ts

@@ -17,7 +17,7 @@ export { displayWidth, truncateMiddleToDisplayWidth, truncateToDisplayWidth, } f
  * 手机（~390px 内容宽）上折叠面板的标题只有**一行**可用：减去图标与内边距约
  * 320px，按 ~7.5px/半角算 ≈ 42 个半角宽度（iPhone SE 更窄，超出时按 `·`/空格
  * 折行仍可读，但不能整段换行）。超过就折行，断点常常落在 URL 或命令
- * 中间（2026-10-19 截图反馈）。完整参数在展开后的正文里，标题只负责"哪个工具、
+ * 中间。完整参数在展开后的正文里，标题只负责"哪个工具、
  * 动了什么"，并带上 `HH:mm` 时间戳（一起计入预算）。
  */
 export declare const HEADER_DISPLAY_MAX = 42;

package/dist/card/tool-render.js

@@ -20,7 +20,7 @@ export { displayWidth, truncateMiddleToDisplayWidth, truncateToDisplayWidth, } f
  * 手机（~390px 内容宽）上折叠面板的标题只有**一行**可用：减去图标与内边距约
  * 320px，按 ~7.5px/半角算 ≈ 42 个半角宽度（iPhone SE 更窄，超出时按 `·`/空格
  * 折行仍可读，但不能整段换行）。超过就折行，断点常常落在 URL 或命令
- * 中间（2026-10-19 截图反馈）。完整参数在展开后的正文里，标题只负责"哪个工具、
+ * 中间。完整参数在展开后的正文里，标题只负责"哪个工具、
  * 动了什么"，并带上 `HH:mm` 时间戳（一起计入预算）。
  */
 export const HEADER_DISPLAY_MAX = 42;

package/dist/card/usage-format.d.ts

@@ -8,6 +8,18 @@
 import type { UsageSnapshot } from '../session-contract.js';
 /** `formatUsageStats` 只读这几项：会话/进度卡片上的紧凑用量行。 */
 export type SessionDisplayUsage = Pick<UsageSnapshot, 'contextLength' | 'contextLimit' | 'compactCount' | 'cacheReadTokens' | 'cacheCreationTokens'>;
+/**
+ * Format number to human-readable unit string.
+ * - >= 999_500: M with at most one decimal (e.g., 999_600 → 1M, 1200000 → 1.2M,
+ *   25000000 → 25M)
+ * - >= 1K: rounded to nearest integer K (e.g., 1500 → 2K, 120000 → 120K)
+ * - < 1K: as-is (e.g., 500 → "500")
+ *
+ * 千位边界取 M 档：999_500 起按 K 四舍五入会得到 "1000K"，直接按 M 档展示。
+ * 此前 run-renderer 另有一份 formatTokens 只在这边带此边界护栏，两处已收敛
+ * 到本函数（run-renderer 的状态行 `📊 N` 也走这里）。
+ */
+export declare function formatTokenK(n: number): string;
 /**
  * Format usage stats (context length, compact count, cache tokens) into a display string.
  * Each stat on its own line with blank lines between sections.

package/dist/card/usage-format.js

@@ -7,12 +7,17 @@
  */
 /**
  * Format number to human-readable unit string.
- * - >= 1M: one decimal, M suffix (e.g., 1200000 → 1.2M, 25000000 → 25M)
+ * - >= 999_500: M with at most one decimal (e.g., 999_600 → 1M, 1200000 → 1.2M,
+ *   25000000 → 25M)
  * - >= 1K: rounded to nearest integer K (e.g., 1500 → 2K, 120000 → 120K)
  * - < 1K: as-is (e.g., 500 → "500")
+ *
+ * 千位边界取 M 档：999_500 起按 K 四舍五入会得到 "1000K"，直接按 M 档展示。
+ * 此前 run-renderer 另有一份 formatTokens 只在这边带此边界护栏，两处已收敛
+ * 到本函数（run-renderer 的状态行 `📊 N` 也走这里）。
  */
-function formatTokenK(n) {
-    if (n >= 1_000_000) {
+export function formatTokenK(n) {
+    if (n >= 999_500) {
         const m = n / 1_000_000;
         const rounded = Math.round(m * 10) / 10;
         // Drop unnecessary ".0" for whole numbers (2.0M → 2M)

package/dist/cli.js

@@ -92,10 +92,17 @@ export async function bootstrap(deps) {
         forwarders.set(sig, forwarder);
         onSignal(sig, forwarder);
     }
-    child.on('error', () => {
+    child.on('error', (err) => {
+        // bun 拉起失败（ENOENT/EACCES）会静默切 node 兜底，但错误本身必须留痕，
+        // 否则「为什么跑在了 node 上」无从排查。logger 此时尚未初始化，console
+        // 是规则允许的启动期例外。
+        console.error('[lark-remote] bun spawn failed, falling back to node:', err);
         for (const [sig, forwarder] of forwarders)
             offSignal(sig, forwarder);
-        void importEntry().catch(() => exit(1));
+        void importEntry().catch((importErr) => {
+            console.error('[lark-remote] node fallback import failed:', importErr);
+            exit(1);
+        });
     });
     child.on('exit', (code, signal) => {
         if (signal) {
@@ -146,7 +153,12 @@ function main() {
         killSelf: (sig) => process.kill(process.pid, sig),
         exit: (code) => process.exit(code),
     };
-    void bootstrap(deps).catch(() => process.exit(1));
+    // bootstrap 是第一接触面：静默 exit(1) 会让安装损坏/依赖缺失表现为零输出
+    // 退出，必须把根因打到 stderr（logger 未初始化，console 为规则允许的例外）。
+    void bootstrap(deps).catch((err) => {
+        console.error('[lark-remote] bootstrap failed:', err);
+        process.exit(1);
+    });
 }
 if (isDirectEntry()) {
     main();

package/dist/clone.js

@@ -237,7 +237,7 @@ export class CloneSession {
             // 图片发送失败不阻断流程：给出浏览器打开兜底。
             await this.connector
                 .sendWithRetry(ctx.chatId, { text: `⚠️ 二维码图片发送失败，请在浏览器打开创建：${info.url}` }, { replyTo: ctx.messageId })
-                .catch(() => { });
+                .catch((err) => getLogger().warn('[clone] fallback notice send failed:', err));
             return;
         }
         finally {
@@ -336,7 +336,7 @@ export class CloneSession {
                     `新应用凭证（请妥善保管）：App ID ${result.client_id}\n` +
                     '可修复本机问题后用 /clone 重新走一遍流程（会创建新应用）',
             }, { replyTo: ctx.messageId })
-                .catch(() => { });
+                .catch((sendErr) => getLogger().warn('[clone] finalize failure notice send failed:', sendErr));
         }
         finally {
             this.state = 'idle';