lark-remote 0.5.19 → 0.5.21

package/dist/session/pi/sessions.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { findJsonlLine } from '../common/jsonl.js';
 import { scanJsonlOnce, tailOffsetAfter, scanTailEvents } from '../common/two-pass.js';
+import { throwSessionListError } from '../common/throw-session-list-error.js';
 import { extractContentBlocks } from '../common/content-blocks.js';
 import { UsageAccumulator, contextWindowOccupancy, cumulativeUsageFields, } from '../common/usage-accumulator.js';
 import { isStale } from '../common/constants.js';
@@ -63,7 +64,7 @@ function extractPiText(content) {
  * dominates displayTitle and squeezes out the user's actual words.
  * Replace the whole `<skill>…</skill>` block with `skill:x`, preserving any
  * trailing real text. Falls back to the original text when no skill block
- * is present (or the block is malformed/unclosed). Regression 2026-07-13.
+ * is present (or the block is malformed/unclosed).
  */
 function compressSkillInjection(text) {
     return text
@@ -193,7 +194,7 @@ function piScalarScan(filePath) {
                 const text = extractPiText(msg.content);
                 // Compress skill-injection bodies so the "最近输入" label shows what
                 // the user invoked (skill:x) + any trailing real input, not a
-                // truncated SKILL.md head. Regression 2026-07-13.
+                // truncated SKILL.md head.
                 if (text)
                     lastUserText = compressSkillInjection(text);
             }
@@ -367,9 +368,7 @@ export class PiSessionReader {
             if (err.code === 'ENOENT') {
                 return [];
             }
-            getLogger().error(`[pi-session-reader] listSessions failed: ${err}`);
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`pi session list 读取失败: ${msg}`, { cause: err });
+            throwSessionListError('pi', err);
         }
         const sessions = [];
         for (const f of files) {

package/dist/session/session-store.d.ts

@@ -1,4 +1,10 @@
 import type { AgentKind } from '../agent-kinds.js';
+/**
+ * session reader 共用的失败留痕（claude stat / kimi realpath）：ENOENT 是两次
+ * 查询之间的正常竞态，静默；其余 errno 必须 debug 留痕，否则「文件不可读」
+ * 会被误判成「会话不活跃」。文案由调用方按场景给出，逐字保持。
+ */
+export declare function logNonEnoentDebug(err: unknown, message: (errText: string) => string): void;
 interface SessionEntry {
     /** Session IDs per agent kind (Map for in-memory, plain object for persistence). */
     sessions: Map<AgentKind, string>;
@@ -30,7 +36,7 @@ export declare class SessionStore {
     private sessions;
     private readonly persistPath?;
     /**
-     * 进程内会话代际（2026-08-09 /new 被在途 run init 写回撤销事故）：
+     * 进程内会话代际（防 /new 被在途 run init 写回撤销）：
      * 每次「用户意图移动 session 指针」+1。system.init 写回通道不 bump。
      * Bridge 在 run 启动时快照 epoch，init 写回前比较——不一致说明 /new、
      * /cd、/resume 等在 run 在途时移动了指针，该 run 的写回是 stale 的，丢弃。
@@ -73,6 +79,8 @@ export declare class SessionStore {
     getArrivalSessionId(userId: string, agent: AgentKind): string | undefined;
     /** Set the arrival baseline for a specific agent ('' explicitly clears the arrival baseline) */
     setArrivalSessionId(userId: string, agent: AgentKind, sessionId: string): void;
+    /** previous/arrival 两类 setter 共用的单一实现（合并完全重复块）。 */
+    private writeSessionId;
     /** Set cwd for a user, clearing all sessionIds (§9.1) */
     setCwd(userId: string, cwd: string): void;
     /** Get cwd for a user, or undefined if no session */

package/dist/session/session-store.js

@@ -1,6 +1,90 @@
 import fs from 'node:fs';
 import { getLogger } from '../logger/index.js';
 import { atomicWriteJson } from '../persistence/atomic-write.js';
+/**
+ * session reader 共用的失败留痕（claude stat / kimi realpath）：ENOENT 是两次
+ * 查询之间的正常竞态，静默；其余 errno 必须 debug 留痕，否则「文件不可读」
+ * 会被误判成「会话不活跃」。文案由调用方按场景给出，逐字保持。
+ */
+export function logNonEnoentDebug(err, message) {
+    if (err.code === 'ENOENT')
+        return;
+    getLogger().debug(message(err?.message ?? String(err)));
+}
+/** 四类 getter 共用的单一实现：entry 缺失 / 空串 → undefined。 */
+function readSessionId(entry, key, agent) {
+    if (!entry)
+        return undefined;
+    const value = entry[key].get(agent);
+    if (!value)
+        return undefined;
+    return value;
+}
+/** 四个 session 字段缺一即损坏记录（整条跳过，cwd 允许缺失）。 */
+function hasRequiredSessionFields(entry) {
+    return (!!entry.sessions && !!entry.previousSessions && !!entry.arrivalSessions && !!entry.sessionCwds);
+}
+/** 只保留 truthy 值（sessions / previousSessions / sessionCwds 的口径）。 */
+function truthySessionMap(record) {
+    const map = new Map();
+    for (const [agent, sid] of Object.entries(record)) {
+        if (sid)
+            map.set(agent, sid);
+    }
+    return map;
+}
+/** 全保留（arrivalSessions 的 '' 是显式清空基线，必须跨重启存活）。 */
+function fullSessionMap(record) {
+    const map = new Map();
+    for (const [agent, sid] of Object.entries(record)) {
+        map.set(agent, sid);
+    }
+    return map;
+}
+/** 单条持久化记录 → 内存 entry；损坏 / 完全空记录返回 undefined。 */
+function parsePersistedEntry(data) {
+    if (typeof data !== 'object' || data === null)
+        return undefined;
+    const entry = data;
+    // 四个 session 字段缺失 = 损坏记录，整条跳过。cwd 允许缺失：
+    // 全新用户（未 /cd）先切 agent 时 previous/arrival 停车位已落盘，
+    // cwd 尚为空——不能因 cwd 缺失把停车位整条丢掉
+    // （anchor_r7_parked_previous_survives_rebuild_without_cwd）。
+    if (!hasRequiredSessionFields(entry))
+        return undefined;
+    const sessions = truthySessionMap(entry.sessions);
+    const previousSessions = truthySessionMap(entry.previousSessions);
+    const arrivalSessions = fullSessionMap(entry.arrivalSessions);
+    const sessionCwds = truthySessionMap(entry.sessionCwds);
+    // Persist any user that has state: cwd set, or any meaningful
+    // sessions/previousSessions value, or any arrival baseline entry
+    // ('' arrivals are meaningful). Fully empty records are skipped.
+    const hasCwd = !!entry.cwd && entry.cwd.length > 0;
+    if (hasCwd || sessions.size > 0 || previousSessions.size > 0 || arrivalSessions.size > 0) {
+        return {
+            sessions,
+            previousSessions,
+            sessionCwds,
+            arrivalSessions,
+            cwd: entry.cwd ?? '',
+        };
+    }
+    return undefined;
+}
+/** 损坏现场留痕：日志 + 改名保留（原文件继续躺着会重复告警、丢排障证据）。 */
+function preserveCorruptStore(persistPath, err) {
+    getLogger().warn(`[session] persisted session store corrupted (${persistPath ?? '(memory)'}), ignoring:`, err);
+    if (persistPath) {
+        const brokenPath = `${persistPath}.corrupt-${Date.now()}`;
+        try {
+            fs.renameSync(persistPath, brokenPath);
+            getLogger().warn(`[session] moved corrupt store to ${brokenPath}`);
+        }
+        catch (renameErr) {
+            getLogger().warn('[session] failed to preserve corrupt store:', renameErr);
+        }
+    }
+}
 /**
  * Per-user session store. Persists cwd + per-agent sessions to disk so that
  * the last cwd AND the last-used sessionId per agent are restored after
@@ -20,7 +104,7 @@ export class SessionStore {
     sessions = new Map();
     persistPath;
     /**
-     * 进程内会话代际（2026-08-09 /new 被在途 run init 写回撤销事故）：
+     * 进程内会话代际（防 /new 被在途 run init 写回撤销）：
      * 每次「用户意图移动 session 指针」+1。system.init 写回通道不 bump。
      * Bridge 在 run 启动时快照 epoch，init 写回前比较——不一致说明 /new、
      * /cd、/resume 等在 run 在途时移动了指针，该 run 的写回是 stale 的，丢弃。
@@ -104,20 +188,11 @@ export class SessionStore {
     }
     /** Get previous sessionId for a specific agent (stored when switching away) */
     getPreviousSessionId(userId, agent) {
-        const entry = this.sessions.get(userId);
-        if (!entry)
-            return undefined;
-        const sessionId = entry.previousSessions.get(agent);
-        if (!sessionId)
-            return undefined;
-        return sessionId;
+        return readSessionId(this.sessions.get(userId), 'previousSessions', agent);
     }
     /** Set previous sessionId for a specific agent (for potential restore when switching back) */
     setPreviousSessionId(userId, agent, sessionId) {
-        this.mutateEntry(userId, (entry) => {
-            entry.previousSessions.set(agent, sessionId);
-            return entry;
-        });
+        this.writeSessionId(userId, 'previousSessions', agent, sessionId);
     }
     /** Clear previous sessionId for a specific agent */
     clearPreviousSessionId(userId, agent) {
@@ -128,18 +203,16 @@ export class SessionStore {
     }
     /** Get the arrival baseline sessionId for a specific agent ('' and missing → undefined) */
     getArrivalSessionId(userId, agent) {
-        const entry = this.sessions.get(userId);
-        if (!entry)
-            return undefined;
-        const sessionId = entry.arrivalSessions.get(agent);
-        if (!sessionId)
-            return undefined;
-        return sessionId;
+        return readSessionId(this.sessions.get(userId), 'arrivalSessions', agent);
     }
     /** Set the arrival baseline for a specific agent ('' explicitly clears the arrival baseline) */
     setArrivalSessionId(userId, agent, sessionId) {
+        this.writeSessionId(userId, 'arrivalSessions', agent, sessionId);
+    }
+    /** previous/arrival 两类 setter 共用的单一实现（合并完全重复块）。 */
+    writeSessionId(userId, key, agent, sessionId) {
         this.mutateEntry(userId, (entry) => {
-            entry.arrivalSessions.set(agent, sessionId);
+            entry[key].set(agent, sessionId);
             return entry;
         });
     }
@@ -165,13 +238,7 @@ export class SessionStore {
     }
     /** Get sessionId for a specific agent, or undefined if no session or sessionId is empty */
     getSessionId(userId, agent = 'claude') {
-        const entry = this.sessions.get(userId);
-        if (!entry)
-            return undefined;
-        const sessionId = entry.sessions.get(agent);
-        if (!sessionId)
-            return undefined;
-        return sessionId;
+        return readSessionId(this.sessions.get(userId), 'sessions', agent);
     }
     /** Set sessionId for a specific agent, optionally with cwd */
     setSessionId(userId, agent, sessionId, cwd) {
@@ -196,13 +263,7 @@ export class SessionStore {
     }
     /** Get sessionCwd for a specific agent, or undefined if not set */
     getSessionCwd(userId, agent = 'claude') {
-        const entry = this.sessions.get(userId);
-        if (!entry)
-            return undefined;
-        const sessionCwd = entry.sessionCwds.get(agent);
-        if (!sessionCwd)
-            return undefined;
-        return sessionCwd;
+        return readSessionId(this.sessions.get(userId), 'sessionCwds', agent);
     }
     /** Set sessionId and sessionCwd for a specific agent, without touching cwd */
     setSessionIdAndSessionCwd(userId, agent, sessionId, sessionCwd) {
@@ -224,75 +285,14 @@ export class SessionStore {
             const parsed = JSON.parse(raw);
             if (typeof parsed === 'object' && parsed !== null) {
                 for (const [userId, data] of Object.entries(parsed)) {
-                    if (typeof data === 'object' && data !== null) {
-                        const entry = data;
-                        // 四个 session 字段缺失 = 损坏记录，整条跳过。cwd 允许缺失：
-                        // 全新用户（未 /cd）先切 agent 时 previous/arrival 停车位已落盘，
-                        // cwd 尚为空——不能因 cwd 缺失把停车位整条丢掉
-                        // （anchor_r7_parked_previous_survives_rebuild_without_cwd）。
-                        if (!entry.sessions ||
-                            !entry.previousSessions ||
-                            !entry.arrivalSessions ||
-                            !entry.sessionCwds) {
-                            continue;
-                        }
-                        const sessions = new Map();
-                        for (const [agent, sid] of Object.entries(entry.sessions)) {
-                            if (sid) {
-                                sessions.set(agent, sid);
-                            }
-                        }
-                        const previousSessions = new Map();
-                        for (const [agent, sid] of Object.entries(entry.previousSessions)) {
-                            if (sid) {
-                                previousSessions.set(agent, sid);
-                            }
-                        }
-                        const arrivalSessions = new Map();
-                        for (const [agent, sid] of Object.entries(entry.arrivalSessions)) {
-                            // '' entries are meaningful: explicit "cleared arrival" must
-                            // survive a restart instead of being re-defaulted.
-                            arrivalSessions.set(agent, sid);
-                        }
-                        const sessionCwds = new Map();
-                        for (const [agent, scwd] of Object.entries(entry.sessionCwds)) {
-                            if (scwd) {
-                                sessionCwds.set(agent, scwd);
-                            }
-                        }
-                        // Persist any user that has state: cwd set, or any meaningful
-                        // sessions/previousSessions value, or any arrival baseline entry
-                        // ('' arrivals are meaningful). Fully empty records are skipped.
-                        const hasCwd = !!entry.cwd && entry.cwd.length > 0;
-                        if (hasCwd ||
-                            sessions.size > 0 ||
-                            previousSessions.size > 0 ||
-                            arrivalSessions.size > 0) {
-                            this.sessions.set(userId, {
-                                sessions,
-                                previousSessions,
-                                sessionCwds,
-                                arrivalSessions,
-                                cwd: entry.cwd ?? '',
-                            });
-                        }
-                    }
+                    const entry = parsePersistedEntry(data);
+                    if (entry)
+                        this.sessions.set(userId, entry);
                 }
             }
         }
         catch (err) {
-            getLogger().warn(`[session] persisted session store corrupted (${this.persistPath ?? '(memory)'}), ignoring:`, err);
-            // 改名保留现场：原文件继续原地躺着会让下次启动重复告警，也丢掉排障证据。
-            if (this.persistPath) {
-                const brokenPath = `${this.persistPath}.corrupt-${Date.now()}`;
-                try {
-                    fs.renameSync(this.persistPath, brokenPath);
-                    getLogger().warn(`[session] moved corrupt store to ${brokenPath}`);
-                }
-                catch (renameErr) {
-                    getLogger().warn('[session] failed to preserve corrupt store:', renameErr);
-                }
-            }
+            preserveCorruptStore(this.persistPath, err);
         }
     }
     autoPersist() {

package/dist/update/version-check.js

@@ -99,7 +99,8 @@ function readCache(cachePath) {
             return null;
         return cached;
     }
-    catch {
+    catch (err) {
+        getLogger().debug('[update] version cache unreadable, refetching:', err);
         return null;
     }
 }

package/dist/workspace/index.d.ts

@@ -11,7 +11,7 @@ export interface WorkspaceEntry {
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the lark-remote can still start.
  *
- * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * lastUsedAt 语义：保存（save）与使用（use/touch）
  * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
  * 对新保存的 cwd 同样生效（新条目应排在列表最前，而非沉底）。
  * 同一毫秒内连续操作时 touch 会用 max+1 保证严格递增，避免 Date.now 相同

package/dist/workspace/index.js

@@ -10,7 +10,7 @@ import { getLogger } from '../logger/index.js';
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the lark-remote can still start.
  *
- * lastUsedAt 语义（2026-08-19 语义对齐）：保存（save）与使用（use/touch）
+ * lastUsedAt 语义：保存（save）与使用（use/touch）
  * 都会把时间戳更新为当前时间。save 内部调用 touch，保证「最近使用」排序
  * 对新保存的 cwd 同样生效（新条目应排在列表最前，而非沉底）。
  * 同一毫秒内连续操作时 touch 会用 max+1 保证严格递增，避免 Date.now 相同

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "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",