lark-remote 0.1.0

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

@@ -0,0 +1,81 @@
+/**
+ * OpencodeSessionReader: CLI-based session reader using `opencode session list` and `opencode export`.
+ *
+ * Design:
+ * - Uses official CLI commands instead of HTTP API.
+ * - `opencode session list --format json` returns sessions with `directory` field (first-class citizen).
+ * - `opencode export <sessionID>` returns full session content.
+ * - Independent of runner (no setRunner circular dependency).
+ *
+ * Key features:
+ * - listSessions: filter by directory field (the canonical session metadata).
+ * - readSessionContent: extract catch-up tail from export messages.
+ * - isSessionActive: use `updated` timestamp with 1 hour stale window.
+ * - Simple memory cache with TTL.
+ */
+import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+interface OpencodeSessionReaderOptions {
+    /** Path to opencode binary. Default: 'opencode' (in PATH). */
+    binary?: string;
+    /** Cache TTL for session list (ms). Default: 10_000. */
+    cacheTtlMs?: number;
+    /**
+     * Override the raw `opencode export <id>` capture (returns the JSON string).
+     * Default routes stdout to a temp file fd to bypass opencode's ~128KB pipe
+     * truncation on large sessions (L1). Injectable for testing.
+     */
+    captureExport?: (sessionId: string) => 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 */
+    private listCache;
+    constructor(opts?: OpencodeSessionReaderOptions);
+    /**
+     * List sessions in a given cwd, using directory field for matching.
+     * Uses realpath for macOS /tmp -> /private/tmp compatibility.
+     * Passes user cwd to execFileSync so opencode CLI returns sessions for the correct directory.
+     */
+    listSessions(cwd: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): {
+        sessions: AgentSession[];
+        total: number;
+    };
+    /**
+     * Get the newest session in a given cwd.
+     */
+    getNewestSession(cwd: string): AgentSession | null;
+    /**
+     * Read session content: extract catch-up tail (last user message + everything after).
+     */
+    readSessionContent(sessionId: string, cwd: string, opts?: {
+        maxEvents?: number;
+    }): SessionContent;
+    /**
+     * Check if a session is active (updated within 1 hour).
+     * Passes cwd to fetchSessionList so it returns sessions for the correct directory.
+     */
+    isSessionActive(sessionId: string, cwd: string): boolean;
+    private realpath;
+    private fetchSessionList;
+    /**
+     * Capture raw `opencode export <sessionId>` output (JSON string). Injectable
+     * via the constructor; the default routes stdout to a temp file fd to bypass
+     * opencode's ~128KB pipe truncation on large sessions (L1).
+     */
+    private captureExport;
+    /**
+     * L1 default transport: run `opencode export` with stdout pointed at a
+     * regular-file fd (NOT a pipe). opencode truncates piped stdout at ~128KB for
+     * large sessions (huge tool_results), breaking JSON.parse; a file fd receives
+     * the full output (verified: 1.3MB parses OK). execFileSync returns null when
+     * stdout is not a pipe, so we read the file instead.
+     */
+    private captureExportViaFileFd;
+}
+export {};

package/dist/session/opencode/sessions.js

@@ -0,0 +1,388 @@
+/**
+ * OpencodeSessionReader: CLI-based session reader using `opencode session list` and `opencode export`.
+ *
+ * Design:
+ * - Uses official CLI commands instead of HTTP API.
+ * - `opencode session list --format json` returns sessions with `directory` field (first-class citizen).
+ * - `opencode export <sessionID>` returns full session content.
+ * - Independent of runner (no setRunner circular dependency).
+ *
+ * Key features:
+ * - listSessions: filter by directory field (the canonical session metadata).
+ * - readSessionContent: extract catch-up tail from export messages.
+ * - isSessionActive: use `updated` timestamp with 1 hour stale window.
+ * - Simple memory cache with TTL.
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { truncateUtf8, TOOL_RESULT_MAX_BYTES } from '../../card/text-truncate.js';
+import { getLogger } from '../../logger/index.js';
+import { STALE_MS } from '../common/constants.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 */
+    listCache = new Map();
+    constructor(opts = {}) {
+        this.binary = opts.binary ?? 'opencode';
+        this.cacheTtlMs = opts.cacheTtlMs ?? 10_000;
+        this.captureExportOverride = opts.captureExport;
+    }
+    /**
+     * List sessions in a given cwd, using directory field for matching.
+     * Uses realpath for macOS /tmp -> /private/tmp compatibility.
+     * Passes user cwd to execFileSync so opencode CLI returns sessions for the correct directory.
+     */
+    listSessions(cwd, opts) {
+        const realCwd = this.realpath(cwd);
+        const entries = this.fetchSessionList(realCwd);
+        // Filter by directory === realpath(cwd)
+        const filtered = entries.filter((e) => 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));
+        // Compute total over the full sorted set, then paginate.
+        const total = filtered.length;
+        const offset = Math.max(0, opts?.offset ?? 0);
+        const limit = opts?.limit;
+        const page = limit === undefined ? filtered.slice(offset) : filtered.slice(offset, offset + limit);
+        return {
+            sessions: page.map((e) => ({
+                sessionId: e.id,
+                // CLI title 字段形状不保证恒为 string（null/缺字段时 router 的
+                // s.summary.trim() 会 TypeError）——非 string 给空串（Review R3 P3-3）。
+                summary: typeof e.title === 'string' ? e.title : '',
+                mtime: e.updated,
+            })),
+            total,
+        };
+    }
+    /**
+     * Get the newest session in a given cwd.
+     */
+    getNewestSession(cwd) {
+        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+    }
+    /**
+     * Read session content: extract catch-up tail (last user message + everything after).
+     */
+    readSessionContent(sessionId, cwd, opts) {
+        const realCwd = this.realpath(cwd);
+        // L1/L3: capture raw export via the injectable seam, then parse. Distinguish
+        // a truly-missing session (empty capture) from a truncated/corrupt one
+        // (non-empty but unparseable) so we never show the misleading "未找到" for
+        // a session whose content is merely too large to pipe through stdout.
+        let raw;
+        try {
+            raw = this.captureExport(sessionId);
+        }
+        catch (err) {
+            getLogger().warn(`[opencode-session-reader] captureExport failed: ${err}`);
+            return { events: [] };
+        }
+        const trimmed = raw?.trim() ?? '';
+        if (!trimmed) {
+            return { events: [] };
+        }
+        let data;
+        try {
+            data = JSON.parse(trimmed);
+        }
+        catch (err) {
+            getLogger().warn(`[opencode-session-reader] export JSON parse failed (truncated/corrupt?), raw bytes=${trimmed.length}: ${err}`);
+            return { events: [] };
+        }
+        try {
+            if (data.info.directory !== realCwd) {
+                return { events: [] };
+            }
+            const events = [];
+            let usage;
+            let aiTitle;
+            let displayTitle;
+            // Find the last user message position (for catch-up tail).
+            // messages are already parsed objects — scan directly instead of
+            // stringify→findLastUserIndex→parse round-trip (review P2-36).
+            let lastUserIndex = -1;
+            for (let i = 0; i < data.messages.length; i++) {
+                if (data.messages[i].info.role === 'user') {
+                    lastUserIndex = i;
+                }
+            }
+            // Process messages from last user message onwards (catch-up tail)
+            const startIndex = lastUserIndex >= 0 ? lastUserIndex : 0;
+            for (let i = startIndex; i < data.messages.length; i++) {
+                const msg = data.messages[i];
+                const timestamp = msg.info.time?.created
+                    ? new Date(msg.info.time.created).toISOString()
+                    : undefined;
+                for (const part of msg.parts) {
+                    if (part.type === 'text') {
+                        // First user text after last user message is displayTitle
+                        if (msg.info.role === 'user' && part.text && !displayTitle) {
+                            displayTitle = part.text;
+                        }
+                        events.push({
+                            type: 'text',
+                            content: part.text ?? '',
+                            timestamp,
+                        });
+                    }
+                    else if (part.type === 'reasoning') {
+                        events.push({
+                            type: 'thinking',
+                            content: part.text ?? '',
+                            timestamp,
+                        });
+                    }
+                    else if (part.type === 'tool') {
+                        // Tool use
+                        if (part.callID && part.state?.input) {
+                            events.push({
+                                type: 'tool_use',
+                                content: JSON.stringify({
+                                    id: part.callID,
+                                    name: part.tool,
+                                    input: part.state.input,
+                                }),
+                                timestamp,
+                            });
+                        }
+                        // Tool result (completed or error)
+                        if (part.callID && part.state?.output) {
+                            const isError = part.state.status === 'error';
+                            const rawOut = isError
+                                ? (part.state.error ?? part.state.output)
+                                : (part.state.output ?? '');
+                            // L2: pre-fold pathological tool_results (e.g. a 500KB file
+                            // listing) via the shared truncateUtf8 primitive, reusing the
+                            // same …（已截断） suffix as the live renderer / card budget.
+                            events.push({
+                                type: 'tool_result',
+                                content: truncateUtf8(rawOut, TOOL_RESULT_MAX_BYTES),
+                                timestamp,
+                            });
+                        }
+                    }
+                }
+                // Track usage from step-finish parts
+                for (const part of msg.parts) {
+                    if (part.type === 'step-finish' && part.tokens) {
+                        // Use the last step-finish tokens (usually the final one).
+                        // ccusage-aligned: cache.write -> cacheCreationTokens.
+                        // contextLength = input + cacheRead + cacheCreation (excludes
+                        // output/reasoning) — the unified context-window occupancy
+                        // contract across all five readers (review P2-8).
+                        usage = {
+                            inputTokens: part.tokens.input,
+                            outputTokens: part.tokens.output,
+                            contextLength: part.tokens.input +
+                                (part.tokens.cache?.read ?? 0) +
+                                (part.tokens.cache?.write ?? 0),
+                            cacheReadTokens: part.tokens.cache?.read,
+                            cacheCreationTokens: part.tokens.cache?.write,
+                            totalTokens: part.tokens.total,
+                        };
+                    }
+                }
+            }
+            // Cumulative (session-wide): sum input/output/total across ALL step-finish
+            // parts in the whole session. The catch-up loop above only scans from
+            // the last user message (= last run) for per-turn usage; cumulative
+            // needs a full scan so multi-run sessions report the true total.
+            let cumInput = 0;
+            let cumOutput = 0;
+            let cumTotal = 0;
+            let cumCacheRead = 0;
+            let cumCacheWrite = 0;
+            for (const msg of data.messages) {
+                for (const part of msg.parts) {
+                    if (part.type === 'step-finish' && part.tokens) {
+                        cumInput += part.tokens.input ?? 0;
+                        cumOutput += part.tokens.output ?? 0;
+                        cumTotal += part.tokens.total ?? 0;
+                        cumCacheRead += part.tokens.cache?.read ?? 0;
+                        cumCacheWrite += part.tokens.cache?.write ?? 0;
+                    }
+                }
+            }
+            if (usage) {
+                usage.cumulativeTotalTokens = cumTotal;
+                usage.cumulativeInputTokens = cumInput;
+                usage.cumulativeOutputTokens = cumOutput;
+                usage.cumulativeCacheReadTokens = cumCacheRead;
+                usage.cumulativeCacheCreationTokens = cumCacheWrite;
+            }
+            else if (cumInput || cumOutput || cumTotal || cumCacheRead || cumCacheWrite) {
+                usage = {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    contextLength: 0,
+                    cumulativeTotalTokens: cumTotal,
+                    cumulativeInputTokens: cumInput,
+                    cumulativeOutputTokens: cumOutput,
+                    cumulativeCacheReadTokens: cumCacheRead,
+                    cumulativeCacheCreationTokens: cumCacheWrite,
+                };
+            }
+            // Use info.title as aiTitle
+            if (data.info.title) {
+                aiTitle = data.info.title;
+            }
+            // If no displayTitle yet, use first user text as fallback
+            if (!displayTitle) {
+                for (const msg of data.messages) {
+                    if (msg.info.role === 'user') {
+                        for (const part of msg.parts) {
+                            if (part.type === 'text' && part.text) {
+                                displayTitle = part.text;
+                                break;
+                            }
+                        }
+                    }
+                    if (displayTitle)
+                        break;
+                }
+            }
+            // Apply maxEvents cap: keep the LAST N events (most recent), matching
+            // CodexSessionReader's slice(-maxEvents). maxEvents limits the catch-up
+            // tail so auto-resume cards don't load the entire session.
+            // P2-7: maxEvents <= 0 returns [] (guards `slice(-0)` full-array trap).
+            const cappedEvents = opts?.maxEvents !== undefined
+                ? opts.maxEvents <= 0
+                    ? []
+                    : events.slice(-opts.maxEvents)
+                : events;
+            return {
+                events: cappedEvents,
+                usage,
+                // opencode run doesn't have background tasks
+                aiTitle,
+                displayTitle,
+            };
+        }
+        catch (err) {
+            getLogger().warn(`[opencode-session-reader] readSessionContent build failed: ${err}`);
+            return { events: [] };
+        }
+    }
+    /**
+     * Check if a session is active (updated within 1 hour).
+     * Passes cwd to fetchSessionList so it returns sessions for the correct directory.
+     */
+    isSessionActive(sessionId, cwd) {
+        const realCwd = this.realpath(cwd);
+        try {
+            const entries = this.fetchSessionList(realCwd);
+            const entry = entries.find((e) => e.id === sessionId && e.directory === realCwd);
+            if (!entry)
+                return false;
+            // Check if updated within STALE_MS
+            return Date.now() - entry.updated < STALE_MS;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- Private helpers ---
+    realpath(cwd) {
+        try {
+            return fs.realpathSync(cwd);
+        }
+        catch {
+            return cwd;
+        }
+    }
+    fetchSessionList(cwd) {
+        const realCwd = this.realpath(cwd);
+        const cached = this.listCache.get(realCwd);
+        if (cached && Date.now() - cached.ts < this.cacheTtlMs) {
+            return cached.data;
+        }
+        try {
+            // Pass cwd to execFileSync so opencode CLI returns sessions for the correct directory
+            const output = execFileSync(this.binary, ['session', 'list', '--format', 'json'], {
+                encoding: 'utf-8',
+                timeout: 10000,
+                // P1-15: default maxBuffer is 1MiB — a large session list (>1MiB JSON)
+                // throws ENOBUFS, which the catch below silently turns into [] and the
+                // 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();
+            // 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 });
+            return data;
+        }
+        catch (err) {
+            // P1-15: 区分「读取失败」与「真空/陈旧 cwd」。
+            // - ENOENT（cwd 已删除或 binary 缺失）：沿用既有契约返回 []——/resume 对
+            //   陈旧 cwd 保持优雅（sessions.test.ts「Stale-cwd coverage gap」+ round10
+            //   探针的跨 reader 空目录不变量都钉死此行为）。
+            // - 其余失败（exit≠0 / ENOBUFS / JSON 解析错误）：上抛可诊断错误，router
+            //   显示「读取失败」——静默 [] 会让用户误以为没有 session，与真空不可区分。
+            if (err.code === 'ENOENT') {
+                return [];
+            }
+            getLogger().error(`[opencode-session-reader] session list failed: ${err}`);
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`opencode session list 读取失败: ${msg}`, { cause: err });
+        }
+    }
+    /**
+     * Capture raw `opencode export <sessionId>` output (JSON string). Injectable
+     * via the constructor; the default routes stdout to a temp file fd to bypass
+     * opencode's ~128KB pipe truncation on large sessions (L1).
+     */
+    captureExport(sessionId) {
+        if (this.captureExportOverride)
+            return this.captureExportOverride(sessionId);
+        return this.captureExportViaFileFd(sessionId);
+    }
+    /**
+     * L1 default transport: run `opencode export` with stdout pointed at a
+     * regular-file fd (NOT a pipe). opencode truncates piped stdout at ~128KB for
+     * large sessions (huge tool_results), breaking JSON.parse; a file fd receives
+     * the full output (verified: 1.3MB parses OK). execFileSync returns null when
+     * stdout is not a pipe, so we read the file instead.
+     */
+    captureExportViaFileFd(sessionId) {
+        const tmp = path.join(os.tmpdir(), `opencode-export-${sessionId}-${process.pid}-${Date.now()}.json`);
+        let fd;
+        try {
+            fd = fs.openSync(tmp, 'w');
+            execFileSync(this.binary, ['export', sessionId], {
+                encoding: 'utf-8',
+                timeout: 30000,
+                stdio: ['ignore', fd, 'pipe'],
+                // P1-15: stderr is piped here; without maxBuffer a chatty CLI (>1MiB
+                // 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,
+            });
+            return fs.readFileSync(tmp, 'utf-8');
+        }
+        finally {
+            if (fd !== undefined) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { }
+            }
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { }
+        }
+    }
+}
+//# sourceMappingURL=sessions.js.map

package/dist/session/pi/index.d.ts

@@ -0,0 +1 @@
+export { PiSessionReader } from './sessions.js';

package/dist/session/pi/index.js

@@ -0,0 +1,2 @@
+export { PiSessionReader } from './sessions.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,27 @@
+import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
+/**
+ * PiSessionReader: reads pi agent sessions from `~/.pi/agent/`.
+ *
+ * pi is file-system based (like Claude), so this implements AgentSessionReader
+ * directly. The session list comes from directory scanning.
+ */
+export declare class PiSessionReader implements AgentSessionReader {
+    private readonly piDir;
+    private readonly sessionsDir;
+    constructor(opts?: {
+        piDir?: string;
+    });
+    listSessions(cwd: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): {
+        sessions: AgentSession[];
+        total: number;
+    };
+    getNewestSession(cwd: string): AgentSession | null;
+    readSessionContent(sessionId: string, cwd: string, opts?: {
+        maxEvents?: number;
+    }): SessionContent;
+    isSessionActive(sessionId: string, cwd: string): boolean;
+    private listSessionsByScan;
+}