lark-remote 0.1.12 → 0.2.0

package/dist/session/kimi/sessions.js

@@ -2,10 +2,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { readJsonlLines as readJsonlLinesShared, readLastNJsonlLines } from '../common/jsonl.js';
-import { UsageAccumulator } from '../common/usage-accumulator.js';
+import { UsageAccumulator, cumulativeUsageFields } from '../common/usage-accumulator.js';
 import { getLogger } from '../../logger/index.js';
-import { STALE_MS } from '../common/constants.js';
+import { isStale } from '../common/constants.js';
+import { samePath } from '../../platform/path.js';
 import { capEvents, paginate } from '../common/pagination.js';
+import { sortByRecencyDesc } from '../common/recency.js';
+import { TtlCache } from '../../common/ttl-cache.js';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 import { truncateToolInput } from '../common/content-blocks.js';
 /** Default Kimi config directory */
@@ -25,6 +28,16 @@ function isTurnPrompt(entry) {
 function isCompactionComplete(entry) {
     return entry.type === 'full_compaction.complete' || entry.type === 'context.apply_compaction';
 }
+/** full_compaction.begin：压缩开始（手动 /compact 或自动触发都写）。 */
+function isCompactionBegin(entry) {
+    return entry.type === 'full_compaction.begin';
+}
+/** 压缩终态：完成（complete/apply）或失败/取消（cancel）共用 cancel 记录。 */
+function isCompactionTerminal(entry) {
+    return (entry.type === 'full_compaction.complete' ||
+        entry.type === 'context.apply_compaction' ||
+        entry.type === 'full_compaction.cancel');
+}
 /**
  * Max lines scanned backwards when looking for the last loop event.
  * Bounds the tail scan so huge wire files are not fully parsed.
@@ -55,10 +68,7 @@ function lastLoopEventIsStepEnd(lines) {
     return false;
 }
 /** Cache for JSONL file contents to avoid repeated full reads */
-const jsonlCache = new Map();
-const CACHE_TTL_MS = 5000; // 5 second cache TTL
-/** Upper bound on cached files; evict the least-recently-used entry past this. */
-const CACHE_MAX_ENTRIES = 32;
+const jsonlCache = new TtlCache(5_000, 32);
 /**
  * Read lines from a JSONL file with caching.
  * Delegates to the shared readJsonlLines for the actual file read,
@@ -68,25 +78,14 @@ function readJsonlLines(filePath) {
     try {
         const stat = fs.statSync(filePath);
         const mtime = stat.mtimeMs;
+        // P1-17: TTL 由 TtlCache 按缓存写入时间判定（不是文件 mtime），命中即 LRU 刷新；
+        // mtime 变化视为失效（文件被改写后不得返回旧行）。
         const cached = jsonlCache.get(filePath);
-        // P1-17: TTL must be measured from the cache-write time (cachedAt), not
-        // the FILE mtime — a file modified an hour ago would otherwise never hit
-        // the cache, making every call re-read and re-write the same entry.
-        if (cached && mtime === cached.mtime && Date.now() - cached.cachedAt < CACHE_TTL_MS) {
-            // LRU refresh on hit: re-insert so recently-used entries survive eviction.
-            jsonlCache.delete(filePath);
-            jsonlCache.set(filePath, cached);
+        if (cached && mtime === cached.mtime) {
             return cached.lines;
         }
         const lines = readJsonlLinesShared(filePath);
-        jsonlCache.set(filePath, { mtime, cachedAt: Date.now(), lines });
-        // P1-17: bound the cache. Map iteration is insertion order; after the LRU
-        // refresh above the least-recently-used entry is the first key.
-        if (jsonlCache.size > CACHE_MAX_ENTRIES) {
-            const oldest = jsonlCache.keys().next().value;
-            if (oldest !== undefined)
-                jsonlCache.delete(oldest);
-        }
+        jsonlCache.set(filePath, { mtime, lines });
         return lines;
     }
     catch {
@@ -126,7 +125,7 @@ export function checkCwdGuard(state, realCwd) {
     const sessionWorkDir = extractWorkDir(state);
     if (sessionWorkDir === undefined)
         return 'unverifiable';
-    if (sessionWorkDir === realCwd)
+    if (samePath(sessionWorkDir, realCwd))
         return 'verified';
     return 'failed';
 }
@@ -211,35 +210,36 @@ export class KimiSessionReader {
             const realCwd = fs.realpathSync(cwd);
             const sessions = [];
             for (const entry of this.scanSessionIndex()) {
-                // Index workDir is v1-only; v2 sessions may have empty/missing workDir.
-                // When index workDir is absent, fall back to state.json's cwd field.
-                let entryWorkDir = entry.workDir;
-                if (!entryWorkDir) {
-                    const statePath = path.join(entry.sessionDir, 'state.json');
+                // W2.7：state.json 一次读取共用（cwd 兜底 + summary），I/O 减半。
+                // 两次 catch 语义保留：解析失败 = 无法判 cwd → 跳过（continue）；
+                // 解析成功但字段缺失 = summary 落 wire.jsonl 提取。
+                const statePath = path.join(entry.sessionDir, 'state.json');
+                let state = null;
+                let stateParsed = false;
+                if (fs.existsSync(statePath)) {
                     try {
-                        if (fs.existsSync(statePath)) {
-                            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-                            entryWorkDir = extractWorkDir(state);
-                        }
+                        state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                        stateParsed = true;
                     }
                     catch {
-                        // Unreadable state — cannot determine cwd, skip
+                        // Corrupt state.json — cannot determine cwd → skip below
                     }
                 }
+                // Index workDir is v1-only; v2 sessions may have empty/missing workDir.
+                // When index workDir is absent, fall back to state.json's cwd field.
+                let entryWorkDir = entry.workDir;
+                if (!entryWorkDir) {
+                    if (stateParsed && state)
+                        entryWorkDir = extractWorkDir(state);
+                    // Unreadable state — cannot determine cwd, entryWorkDir stays undefined
+                }
                 if (entryWorkDir !== realCwd) {
                     continue;
                 }
-                const statePath = path.join(entry.sessionDir, 'state.json');
                 let summary = 'New Session';
-                if (fs.existsSync(statePath)) {
-                    try {
-                        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-                        // v1: state.title / state.lastPrompt; v2: these fields may be absent
-                        summary = state.title || state.lastPrompt || '';
-                    }
-                    catch {
-                        // Corrupt state.json — fall through to wire.jsonl extraction
-                    }
+                if (stateParsed && state) {
+                    // v1: state.title / state.lastPrompt; v2: these fields may be absent
+                    summary = state.title || state.lastPrompt || '';
                 }
                 // v2 state.json omits title/lastPrompt: extract from wire.jsonl's last
                 // turn.prompt instead. Only scan a small tail to find it — the summary
@@ -271,7 +271,7 @@ export class KimiSessionReader {
             }
             // Sort by mtime descending; same-mtime ties use a deterministic
             // secondary key so ordering is stable across scans.
-            sessions.sort((a, b) => b.mtime - a.mtime || a.sessionId.localeCompare(b.sessionId));
+            sortByRecencyDesc(sessions, (s) => s.mtime, (s) => s.sessionId);
             const { items, total } = paginate(sessions, opts ?? {});
             return {
                 sessions: items,
@@ -469,11 +469,7 @@ export class KimiSessionReader {
                 totalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
                 // Cumulative (session-wide): kimi sums all usage.records; mirrors
                 // inputTokens/outputTokens which are already session totals.
-                cumulativeTotalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
-                cumulativeInputTokens: t.input,
-                cumulativeOutputTokens: t.output,
-                cumulativeCacheReadTokens: t.cacheRead > 0 ? t.cacheRead : 0,
-                cumulativeCacheCreationTokens: t.cacheCreation > 0 ? t.cacheCreation : 0,
+                ...cumulativeUsageFields(t),
                 // §6.3: compaction stats from wire.jsonl
                 compactCount,
                 ...(compactPreContextLength !== undefined ? { compactPreContextLength } : {}),
@@ -490,11 +486,12 @@ export class KimiSessionReader {
         }
     }
     /**
-     * Read the compaction records (context.apply_compaction /
-     * full_compaction.complete) from a session's wire.jsonl.
+     * Read the compaction records (full_compaction.begin / complete / cancel /
+     * context.apply_compaction) from a session's wire.jsonl.
      *
      * Same cwd guard as readSessionContent. Used by KimiAcpRunner.runCompact
-     * (R2) to wait for the background compaction to land before ending the run.
+     * to wait for the background compaction terminal before ending the run, and
+     * by readCompactionState to detect an in-flight compaction.
      */
     readCompactionRecords(sessionId, cwd) {
         const wirePath = this.resolveSessionWirePath(sessionId, cwd);
@@ -506,9 +503,10 @@ export class KimiSessionReader {
             for (const line of readJsonlLines(wirePath)) {
                 try {
                     const entry = JSON.parse(line);
-                    if (isCompactionComplete(entry)) {
+                    if (isCompactionBegin(entry) || isCompactionTerminal(entry)) {
                         records.push({
                             type: entry.type,
+                            ...(entry.source !== undefined ? { source: entry.source } : {}),
                             ...(entry.compactedCount !== undefined
                                 ? { compactedCount: entry.compactedCount }
                                 : {}),
@@ -530,11 +528,34 @@ export class KimiSessionReader {
         return records;
     }
     /**
-     * Resolve the main wire.jsonl path for a session after passing the cwd
-     * guard (state.json + session index fallback). Returns null when the
-     * session is unknown, fails the guard, or has no wire file.
+     * 由 begin/terminal 记录重建压缩状态机：最后一次 begin 无更新的 terminal
+     * 记录 = 在途（kimi-compact-wait-redesign §5.1）。崩溃墓碑由 kimi resume
+     * 时补写 full_compaction.cancel，天然闭合。
      */
-    resolveSessionWirePath(sessionId, cwd) {
+    readCompactionState(sessionId, cwd) {
+        const records = [...this.readCompactionRecords(sessionId, cwd)].sort((a, b) => a.time - b.time);
+        let pendingBeginAt;
+        for (const record of records) {
+            if (isCompactionBegin(record)) {
+                pendingBeginAt = record.time;
+            }
+            else {
+                // 终态（complete/apply/cancel）闭合当前在途压缩。
+                pendingBeginAt = undefined;
+            }
+        }
+        return {
+            inFlight: pendingBeginAt !== undefined,
+            ...(pendingBeginAt !== undefined ? { inFlightSince: pendingBeginAt } : {}),
+            records,
+        };
+    }
+    /**
+     * W2.5 单源：resolveSessionWirePath 与 isSessionActive 共用的 cwd 守卫
+     * （realpathSync → state.json workDir/cwd 三态 → index workDir 兜底 →
+     * fail-closed）。返回 sessionDir；会话未知或守卫不过返回 null。
+     */
+    verifySessionCwd(sessionId, cwd) {
         // Find session directory from index (also retrieve index entry for
         // fallback cwd guard when state.json is missing or unparseable)
         const indexEntry = this.findSessionIndexEntry(sessionId);
@@ -542,7 +563,6 @@ export class KimiSessionReader {
         if (!sessionDir) {
             return null;
         }
-        const statePath = path.join(sessionDir, 'state.json');
         let realCwd;
         try {
             realCwd = fs.realpathSync(cwd);
@@ -552,6 +572,7 @@ export class KimiSessionReader {
             return null;
         }
         let cwdGuardPassed = false;
+        const statePath = path.join(sessionDir, 'state.json');
         try {
             if (fs.existsSync(statePath)) {
                 const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
@@ -559,13 +580,12 @@ export class KimiSessionReader {
                 if (guardResult === 'failed') {
                     return null;
                 }
-                if (guardResult === 'unverifiable') {
-                    getLogger().warn(`[kimi-session-reader] state.json has no workDir/cwd field for session ${sessionId}, falling back to index workDir`);
-                    // Fall through to index-based guard below
+                if (guardResult === 'verified') {
+                    cwdGuardPassed = true;
                 }
                 else {
-                    // verified — state.json cwd matches
-                    cwdGuardPassed = true;
+                    getLogger().warn(`[kimi-session-reader] state.json has no workDir/cwd field for session ${sessionId}, falling back to index workDir`);
+                    // Fall through to index-based guard below
                 }
             }
         }
@@ -591,7 +611,18 @@ export class KimiSessionReader {
                 return null;
             }
         }
-        const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
+        return { sessionDir };
+    }
+    /**
+     * Resolve the main wire.jsonl path for a session after passing the cwd
+     * guard (state.json + session index fallback). Returns null when the
+     * session is unknown, fails the guard, or has no wire file.
+     */
+    resolveSessionWirePath(sessionId, cwd) {
+        const verified = this.verifySessionCwd(sessionId, cwd);
+        if (!verified)
+            return null;
+        const wirePath = path.join(verified.sessionDir, 'agents', 'main', 'wire.jsonl');
         if (!fs.existsSync(wirePath)) {
             return null;
         }
@@ -601,46 +632,11 @@ export class KimiSessionReader {
      * Check if a session is currently active
      */
     isSessionActive(sessionId, cwd) {
-        const indexEntry = this.findSessionIndexEntry(sessionId);
-        const sessionDir = indexEntry?.sessionDir;
-        if (!sessionDir) {
+        // W2.5：cwd 守卫与 resolveSessionWirePath 共用 verifySessionCwd（单源）。
+        const verified = this.verifySessionCwd(sessionId, cwd);
+        if (!verified)
             return false;
-        }
-        // Cwd guard: the session's working directory must match the requested
-        // cwd (align with claude/pi/opencode). Mirrors readSessionContent's
-        // fail-closed cwd check (state.json workDir/cwd, then index workDir).
-        let realCwd;
-        try {
-            realCwd = fs.realpathSync(cwd);
-        }
-        catch {
-            return false;
-        }
-        let cwdGuardPassed = false;
-        const statePath = path.join(sessionDir, 'state.json');
-        try {
-            if (fs.existsSync(statePath)) {
-                const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-                const guardResult = checkCwdGuard(state, realCwd);
-                if (guardResult === 'failed')
-                    return false;
-                if (guardResult === 'verified')
-                    cwdGuardPassed = true;
-            }
-        }
-        catch {
-            // state.json unparseable — fall through to index-based guard
-        }
-        if (!cwdGuardPassed) {
-            const indexWorkDir = indexEntry?.workDir;
-            if (indexWorkDir && indexWorkDir !== realCwd)
-                return false;
-            // v2 sessions have empty index workDir (v1-only field) and may lack
-            // state.json cwd — fail-closed to prevent cross-workspace access.
-            if (!indexWorkDir)
-                return false;
-        }
-        const wirePath = path.join(sessionDir, 'agents', 'main', 'wire.jsonl');
+        const wirePath = path.join(verified.sessionDir, 'agents', 'main', 'wire.jsonl');
         if (!fs.existsSync(wirePath)) {
             return false;
         }
@@ -648,7 +644,7 @@ export class KimiSessionReader {
             const stat = fs.statSync(wirePath);
             const now = Date.now();
             // Check mtime freshness
-            if (now - stat.mtimeMs > STALE_MS) {
+            if (isStale(stat.mtimeMs, now)) {
                 return false;
             }
             // Read the tail to check for active indicators. kimi appends

package/dist/session/opencode/sessions.d.ts

@@ -24,25 +24,13 @@ interface OpencodeSessionReaderOptions {
      */
     captureExport?: (sessionId: string) => string;
 }
-interface OpencodeSessionListEntry {
-    id: string;
-    title: string;
-    updated: number;
-    created: number;
-    projectId: string;
-    directory: string;
-}
 export declare class OpencodeSessionReader implements AgentSessionReader {
     private readonly binary;
     private readonly cacheTtlMs;
     /** Optional raw-export capture override (testing / alt transport). */
     private readonly captureExportOverride?;
-    /** Cache keyed by cwd - each cwd has its own cache entry */
-    /** cwd → 列表缓存（public：测试直接断言缓存形状，替代 as unknown as）。 */
-    listCache: Map<string, {
-        ts: number;
-        data: OpencodeSessionListEntry[];
-    }>;
+    /** cwd → 列表缓存（TTL 由 cacheTtlMs 决定）。 */
+    private listCache;
     constructor(opts?: OpencodeSessionReaderOptions);
     /**
      * List sessions in a given cwd, using directory field for matching.

package/dist/session/opencode/sessions.js

@@ -13,26 +13,29 @@
  * - isSessionActive: use `updated` timestamp with 1 hour stale window.
  * - Simple memory cache with TTL.
  */
-import { execFileSync } from 'node:child_process';
+import { spawnProcessSync } from '../../platform/spawn.js';
 import fs from 'node:fs';
 import { silentlyUnlink } from '../../common/fs.js';
 import os from 'node:os';
 import path from 'node:path';
 import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../common/truncate.js';
 import { getLogger } from '../../logger/index.js';
-import { STALE_MS } from '../common/constants.js';
+import { isStale } from '../common/constants.js';
+import { samePath } from '../../platform/path.js';
 import { paginate, capEvents } from '../common/pagination.js';
+import { sortByRecencyDesc } from '../common/recency.js';
+import { TtlCache } from '../../common/ttl-cache.js';
 export class OpencodeSessionReader {
     binary;
     cacheTtlMs;
     /** Optional raw-export capture override (testing / alt transport). */
     captureExportOverride;
-    /** Cache keyed by cwd - each cwd has its own cache entry */
-    /** cwd → 列表缓存（public：测试直接断言缓存形状，替代 as unknown as）。 */
-    listCache = new Map();
+    /** cwd → 列表缓存（TTL 由 cacheTtlMs 决定）。 */
+    listCache;
     constructor(opts = {}) {
         this.binary = 'opencode';
         this.cacheTtlMs = opts.cacheTtlMs ?? 10_000;
+        this.listCache = new TtlCache(this.cacheTtlMs);
         this.captureExportOverride = opts.captureExport;
     }
     /**
@@ -44,10 +47,10 @@ export class OpencodeSessionReader {
         const realCwd = this.realpath(cwd);
         const entries = this.fetchSessionList(realCwd);
         // Filter by directory === realpath(cwd)
-        const filtered = entries.filter((e) => e.directory === realCwd);
+        const filtered = entries.filter((e) => samePath(e.directory, realCwd));
         // Sort by updated descending; same-updated ties use id as a deterministic
         // secondary key so CLI/list-cache rebuilds never reorder the page.
-        filtered.sort((a, b) => b.updated - a.updated || a.id.localeCompare(b.id));
+        sortByRecencyDesc(filtered, (s) => s.updated, (s) => s.id);
         // Compute total over the full sorted set, then paginate.
         const { items, total } = paginate(filtered, opts ?? {});
         return {
@@ -279,11 +282,11 @@ export class OpencodeSessionReader {
         const realCwd = this.realpath(cwd);
         try {
             const entries = this.fetchSessionList(realCwd);
-            const entry = entries.find((e) => e.id === sessionId && e.directory === realCwd);
+            const entry = entries.find((e) => e.id === sessionId && samePath(e.directory, realCwd));
             if (!entry)
                 return false;
             // Check if updated within STALE_MS
-            return Date.now() - entry.updated < STALE_MS;
+            return !isStale(entry.updated);
         }
         catch {
             return false;
@@ -302,12 +305,16 @@ export class OpencodeSessionReader {
     fetchSessionList(cwd) {
         const realCwd = this.realpath(cwd);
         const cached = this.listCache.get(realCwd);
-        if (cached && Date.now() - cached.ts < this.cacheTtlMs) {
-            return cached.data;
+        if (cached) {
+            return cached;
         }
         try {
+            // spawnProcessSync（cross-spawn）而非 execFileSync：opencode 是 npm 安装
+            // 的 .cmd 垫片，win32 上 execFileSync 不做 PATHEXT 解析会直接 ENOENT，
+            // 会话列表永远为空；cross-spawn 走与 runner spawn 相同的垫片执行路径
+            // （posix 为 child_process.spawnSync 直通，行为不变）。
             // Pass cwd to execFileSync so opencode CLI returns sessions for the correct directory
-            const output = execFileSync(this.binary, ['session', 'list', '--format', 'json'], {
+            const res = spawnProcessSync(this.binary, ['session', 'list', '--format', 'json'], {
                 encoding: 'utf-8',
                 timeout: 10000,
                 // P1-15: default maxBuffer is 1MiB — a large session list (>1MiB JSON)
@@ -315,14 +322,26 @@ export class OpencodeSessionReader {
                 // user sees "no sessions" even though the CLI returned healthy data.
                 maxBuffer: 64 * 1024 * 1024,
                 cwd: realCwd, // Key fix: pass user cwd to CLI
-            }).trim();
+                windowsHide: true, // opencode 是 npm .cmd 垫片：不隐藏会闪 cmd.exe 控制台
+            });
+            if (res.error) {
+                const enoent = res.error.code === 'ENOENT';
+                if (enoent)
+                    return [];
+                throw res.error;
+            }
+            if (res.status !== 0) {
+                const stderr = String(res.stderr ?? '').trim();
+                throw new Error(`exit ${res.status}${stderr ? `: ${stderr}` : ''}`);
+            }
+            const output = String(res.stdout ?? '').trim();
             // CLI returns empty string when no sessions exist - treat as empty array
             if (!output) {
                 return [];
             }
             const data = JSON.parse(output);
             // Update cache keyed by cwd
-            this.listCache.set(realCwd, { ts: Date.now(), data });
+            this.listCache.set(realCwd, data);
             return data;
         }
         catch (err) {
@@ -363,7 +382,7 @@ export class OpencodeSessionReader {
         let fd;
         try {
             fd = fs.openSync(tmp, 'w');
-            execFileSync(this.binary, ['export', sessionId], {
+            spawnProcessSync(this.binary, ['export', sessionId], {
                 encoding: 'utf-8',
                 timeout: 30000,
                 stdio: ['ignore', fd, 'pipe'],
@@ -371,6 +390,7 @@ export class OpencodeSessionReader {
                 // stderr) would throw ENOBUFS and lose the export. Keep the default
                 // stdout file-fd transport unaffected by raising the pipe cap.
                 maxBuffer: 64 * 1024 * 1024,
+                windowsHide: true,
             });
             return fs.readFileSync(tmp, 'utf-8');
         }