lark-remote 0.5.6 → 0.5.8

package/dist/session/dsh/sessions.js

@@ -24,6 +24,7 @@ import { dshArgs, extractDshToken } from '../../runner/dsh/client.js';
 import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecretSync, resolveDshCredentialsFile, } from '../../runner/dsh/auth.js';
 import { capEvents, paginate } from '../common/pagination.js';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
+import { summarizeToolInput } from '../../common/tool-summary.js';
 /**
  * history 拉取上限。DSH session/page 的 maxMessages 同时限制返回条数，
  * 若用它同时充当展示截断，>50 事件的会话累计 usage 会少算。这里拉取一个足够大的
@@ -171,9 +172,9 @@ export class DshSessionReader {
                 .filter((i) => i.cwd !== undefined && samePath(i.cwd, cwd))
                 .map((i) => ({
                 sessionId: String(i.sessionId),
-                summary: '',
                 mtime: i.updatedAt,
                 ...sessionPreset(i),
+                ...sessionPreview(i),
             }));
             sortByRecencyDesc(filtered, (i) => i.mtime, (i) => i.sessionId);
             const { items: page, total } = paginate(filtered, opts ?? {});
@@ -199,6 +200,8 @@ export class DshSessionReader {
                 return { events: [] };
             }
             const throughSeq = this.resolveThroughSeq(sessionId, session);
+            // 服务端投影带来的标题与末轮输入：详情卡头部用它们，不必再从事件里猜。
+            const preview = sessionPreview(session);
             const value = this.unary('session/page', {
                 address: { kind: 'session', sessionId },
                 throughSeq,
@@ -218,6 +221,8 @@ export class DshSessionReader {
             // null = 历史里没有 turn 标记（旧数据/截断）→ 退回末条 usage 语义。
             let turnUsage = null;
             let lastTurnUsage = null;
+            /** 等结果的工具调用（见 MappedEvent.pendingTool）。 */
+            let pendingTool;
             for (const entry of value.records ?? []) {
                 const ev = entry.event;
                 if (!ev)
@@ -231,7 +236,30 @@ export class DshSessionReader {
                     turnUsage = null;
                 }
                 const contentEvents = mapEvent(ev);
-                events.push(...contentEvents.events);
+                if (contentEvents.pendingTool) {
+                    // 未完成的工具调用最多同时一个（DSH 按 step 串行执行；并行调用时按
+                    // 到达顺序配对，最坏情况是两次调用共用一个面板，不会丢信息）。
+                    if (pendingTool)
+                        events.push(pendingTool);
+                    pendingTool = contentEvents.pendingTool;
+                }
+                else if (ev.type === 'tool/result' && pendingTool && contentEvents.events[0]) {
+                    const result = contentEvents.events[0];
+                    // 标题沿用调用的 `🔧 name — summary`，失败改成 ❌（折叠态一眼看出结果）。
+                    const failed = result.title?.startsWith('🔴') === true;
+                    events.push({
+                        type: 'tool_use',
+                        title: failed
+                            ? (pendingTool.title ?? '❌ 工具').replace('🔧', '❌')
+                            : pendingTool.title,
+                        content: result.content,
+                        timestamp: pendingTool.timestamp,
+                    });
+                    pendingTool = undefined;
+                }
+                else {
+                    events.push(...contentEvents.events);
+                }
                 if (contentEvents.title)
                     displayTitle = contentEvents.title;
                 const u = contentEvents.usage;
@@ -278,12 +306,19 @@ export class DshSessionReader {
                     }),
                 };
             }
+            // 中断/仍在执行的调用没有结果：把它当独立事件留下，别让这一条消失。
+            if (pendingTool)
+                events.push(pendingTool);
+            // 头部信息口径：最近输入优先用服务端末轮 prompt（事件里可能只是当前 turn
+            // 的一部分），标题用服务端 title；两者都缺时保持原行为。
+            const headerLastInput = preview.lastUserMessage ?? displayTitle;
             return {
                 // 展示仍按 maxEvents 尾截断（默认 50，保持原行为），usage 已在上面基于
                 // 完整 history 累加。
                 events: capEvents(events, opts?.maxEvents ?? 50),
                 ...(sessionUsage ? { usage: sessionUsage } : {}),
-                ...(displayTitle ? { displayTitle } : {}),
+                ...(headerLastInput ? { displayTitle: headerLastInput } : {}),
+                ...(preview.title ? { aiTitle: preview.title } : {}),
             };
         }
         catch (error) {
@@ -324,9 +359,77 @@ function sessionPreset(item) {
     const preset = item.projections?.values?.agentPreset ?? item.agentPreset;
     return preset ? { agentPreset: preset } : {};
 }
+/**
+ * 会话预览（列表卡上的「标题 / 最近输入 / 最后输出」）。
+ *
+ * 全部取自 `session/list` 的 `projections.values`——DSH 0.2.x 已经随列表一起
+ * 返回 title 与 turnOutline（每轮的 prompt/response），所以这里不需要再拉
+ * `session/page`：那是一次上万条事件的大响应，一页 5 个会话就是 5 次。
+ *
+ * `turnOutline` 的 prompt/response 由 DSH 侧按长度截断（结尾带 `…`），列表卡
+ * 只做单行预览，直接复用即可。缺字段 / 类型不对时全部留空，不影响列表。
+ */
+function sessionPreview(item) {
+    const values = item.projections?.values;
+    const rawTitle = values?.title;
+    const title = typeof rawTitle === 'string' ? rawTitle.trim() : '';
+    const outline = values?.turnOutline;
+    const lastUserMessage = lastOutlineText(outline, 'prompt');
+    const lastAssistantMessage = lastOutlineText(outline, 'response');
+    return {
+        // summary 同时填标题：只认 summary 的消费方（旧卡片路径、其他 agent 的
+        // 统一逻辑）也能拿到可读文本，不必区分 agent。
+        summary: title,
+        ...(title ? { title } : {}),
+        ...(lastUserMessage ? { lastUserMessage } : {}),
+        ...(lastAssistantMessage ? { lastAssistantMessage } : {}),
+    };
+}
+/**
+ * 从 turnOutline 末条往回找第一个非空文本。
+ *
+ * 在途 turn 已经写进 outline，但 `response` 还是空串（实测末条
+ * `{turn:6, prompt:"…", response:""}`）；直接取末条会让「最后输出」空掉，
+ * 所以回溯到最近一条有内容的结果。
+ */
+function lastOutlineText(outline, key) {
+    if (!Array.isArray(outline))
+        return undefined;
+    for (let i = outline.length - 1; i >= 0; i -= 1) {
+        const entry = outline[i];
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const raw = entry[key];
+        if (typeof raw !== 'string')
+            continue;
+        const text = raw.trim();
+        if (text)
+            return text;
+    }
+    return undefined;
+}
 function emptyUsageTotals() {
     return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
+/**
+ * `user/message.source.kind` 里属于**纯上下文注入**的种类：没有回顾价值，且
+ * 会挤掉真正的对话（5 条事件的窗口里被它们占满就什么都看不到了）。
+ */
+const CONTEXT_INJECTION_KINDS = new Set([
+    'time-context',
+    'agent-instructions',
+    'runtime-context',
+    'skill-catalog',
+    'compact-checkpoint',
+]);
+/** 系统通知（后台任务完成、目标变更）在回顾卡里的正文上限。 */
+const NOTICE_MAX_BYTES = 400;
+/** 单条思考在 resume 卡里的上限：过程信息，留头几百字即可。 */
+const REASONING_MAX_BYTES = 800;
+/** 单条 assistant 正文上限（最终答复通常最重要，给足空间）。 */
+const TEXT_MAX_BYTES = 2_000;
+/** 工具原始参数上限（标题已有摘要，正文只用于看完整命令）。 */
+const TOOL_INPUT_MAX_BYTES = 600;
 /** Map one DSH SessionEvent to display content events (+ title/usage side effects). */
 function mapEvent(ev) {
     const out = { events: [] };
@@ -337,42 +440,79 @@ function mapEvent(ev) {
                 .filter((c) => c.type === 'text')
                 .map((c) => c.text ?? '')
                 .join('');
-            out.events.push({ type: 'user', content: text, timestamp: new Date(ev.time).toISOString() });
+            if (!text.trim())
+                break;
+            // DSH 把上下文注入也写成 user/message，靠 `source.kind` 区分。真实会话里
+            // 30 条 user/message 中只有 8 条是用户本人说的（其余是 time-context /
+            // agent-instructions / skill-catalog / goal / tool-jobs…）——照单全收会让
+            // 回顾卡里塞满"Time sampled while preparing turn…"，还把系统提示标成 👤 你。
+            const source = ev.data.source;
+            const kind = typeof source?.kind === 'string' ? source.kind : undefined;
+            if (kind && CONTEXT_INJECTION_KINDS.has(kind))
+                break;
+            const isNotice = kind !== undefined && kind !== 'user';
+            out.events.push({
+                type: isNotice ? 'notice' : 'user',
+                ...(isNotice ? { title: '🔔 通知' } : {}),
+                content: isNotice ? truncateUtf8(text.trim(), NOTICE_MAX_BYTES) : text,
+                timestamp: new Date(ev.time).toISOString(),
+            });
             break;
         }
         case 'assistant/message': {
             const content = ev.data.message
                 ?.content ?? [];
-            const text = content
-                .filter((c) => c.type === 'text')
-                .map((c) => c.text ?? '')
-                .join('');
-            if (text)
-                out.events.push({
-                    type: 'assistant',
-                    content: text,
-                    timestamp: new Date(ev.time).toISOString(),
-                });
+            const timestamp = new Date(ev.time).toISOString();
+            // DSH 的块类型是 text / reasoning / tool-call（不是 Anthropic 的
+            // thinking）。只认 text 会让 resume 卡"只有工具调用、没有思考与输出"
+            // （2026-10-19 反馈：一个 31 turn 的会话里 reasoning 块 371 个、text 12 个，
+            // 全被丢掉）。tool-call 块不在这里取——独立的 `tool/call` 事件带完整参数。
+            for (const block of content) {
+                const text = typeof block.text === 'string' ? block.text.trim() : '';
+                if (!text)
+                    continue;
+                if (block.type === 'text') {
+                    out.events.push({
+                        type: 'assistant',
+                        content: truncateUtf8(text, TEXT_MAX_BYTES),
+                        timestamp,
+                    });
+                }
+                else if (block.type === 'reasoning') {
+                    out.events.push({
+                        type: 'thinking',
+                        // 思考是过程信息：resume 卡里留头几百字足够判断"当时在想什么"。
+                        content: truncateUtf8(text, REASONING_MAX_BYTES),
+                        timestamp,
+                    });
+                }
+            }
             const usage = ev.data.usage;
             if (usage && typeof usage === 'object')
                 out.usage = usage;
             break;
         }
         case 'tool/call': {
+            // 调用本身先不产出事件：DSH 的 tool/call 与 tool/result 是一对，resume 卡
+            // 里合成一个面板（`🔧 bash — cmd` + 输出），而不是两个各占一屏。
             const name = String(ev.data.name ?? '');
             const args = typeof ev.data.arguments === 'string' ? ev.data.arguments : '';
-            out.events.push({
+            const summary = summarizeToolInput(name, args);
+            out.pendingTool = {
                 type: 'tool_use',
-                content: `${name}(${truncateUtf8(args, 200)})`,
+                title: summary ? `🔧 ${name} — ${summary}` : `🔧 ${name}`,
+                content: truncateUtf8(args, TOOL_INPUT_MAX_BYTES),
                 timestamp: new Date(ev.time).toISOString(),
-            });
+            };
             break;
         }
         case 'tool/result': {
             const msg = ev.data.message;
             const raw = stringifyContent(msg?.content);
+            const isError = msg?.isError === true;
             out.events.push({
                 type: 'tool_result',
+                title: isError ? '🔴 结果（失败）' : '🟢 结果',
                 content: truncateUtf8(raw, TOOL_RESULT_MAX_BYTES),
                 timestamp: new Date(ev.time).toISOString(),
             });

package/dist/update/install.js

@@ -102,7 +102,7 @@ export function detectPackageManager(scriptPath) {
             return inferred;
     }
     // 3. availability fallback: 纯 Node PATH 解析（win32 PATHEXT），不再依赖外部 which
-    //    （Windows 无 which）；win32 再用 where.exe 兜底罕见的解析失败场景（v2 §4.3）
+    //    （Windows 无 which）；win32 再用 where.exe 兜底罕见的解析失败场景
     const candidates = ['npm', 'bun', 'pnpm'];
     for (const cmd of candidates) {
         if (resolveExecutable(cmd))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",