lark-remote 0.5.20 → 0.5.21

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
@@ -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/package.json

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