lark-remote 0.1.0

package/dist/session/pi/sessions.js

@@ -0,0 +1,399 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { findJsonlLine, scanJsonlLines, readJsonlLinesFromOffset } from '../common/jsonl.js';
+import { extractContentBlocks } from '../common/content-blocks.js';
+import { UsageAccumulator } from '../common/usage-accumulator.js';
+import { truncate } from '../../card/card-shared.js';
+import { STALE_MS } from '../common/constants.js';
+function defaultPiDir() {
+    return path.join(os.homedir(), '.pi', 'agent');
+}
+/** Encode cwd to pi's directory name format: '--<cwd-with-/->- + '-' --' */
+function projectDirForCwd(cwd, sessionsDir) {
+    const encodedCwd = cwd.replace(/^\//, '').replace(/\//g, '-');
+    const encoded = `--${encodedCwd}--`;
+    return path.join(sessionsDir, encoded);
+}
+/**
+ * P1-19: TTL cache for pi directory scans (mirror codex getSessionIndex's
+ * 5s TTL). Repeated /resume pages re-scan the whole sessions dir per call.
+ */
+const PI_LIST_TTL_MS = 5000;
+/** Upper bound on cached listings; FIFO eviction past this. */
+const PI_LIST_MAX_ENTRIES = 32;
+const piListCache = new Map();
+/** Pi-specific field-name mapping for content block extraction. */
+const PI_MAPPING = {
+    toolUseType: 'toolCall',
+    toolResultType: 'toolResult',
+    toolInputField: 'arguments',
+    toolErrorField: 'isError',
+};
+/** Extract text from a pi content array (first text block). */
+function extractPiText(content) {
+    if (typeof content === 'string')
+        return content.trim() || null;
+    if (!Array.isArray(content))
+        return null;
+    for (const part of content) {
+        if (part && typeof part === 'object') {
+            const p = part;
+            if (p.type === 'text' && typeof p.text === 'string' && p.text.trim()) {
+                return p.text.trim();
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Compress a pi skill-injection body to `skill:<name>`.
+ *
+ * pi wraps an invoked SKILL.md as `<skill name="x" location="...">…</skill>`
+ * and injects it through the user channel - often followed by the user's
+ * real input on a new line. Without compression the multi-KB body head
+ * 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.
+ */
+function compressSkillInjection(text) {
+    return text
+        .replace(/<skill\s+name="([^"]+)"[^>]*>[\s\S]*?<\/skill>/g, (_m, name) => `skill:${name}`)
+        .trim();
+}
+/** Get a one-line summary from a pi session JSONL (first user message text).
+ *
+ * P2-3 optimization: previously used `readJsonlLines` (full-file slurp)
+ * just to get the first user message. Now uses `findJsonlLine` which
+ * stops reading as soon as the predicate matches — typically only the
+ * first few lines of the file, saving ~99% I/O on large sessions.
+ */
+function summarizePiSession(filePath) {
+    const line = findJsonlLine(filePath, (l) => {
+        try {
+            const obj = JSON.parse(l);
+            return (obj.type === 'message' &&
+                obj.message?.role === 'user' &&
+                !!extractPiText(obj.message.content));
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!line)
+        return '(无摘要)';
+    try {
+        const obj = JSON.parse(line);
+        return extractPiText(obj.message?.content) ?? '(无摘要)';
+    }
+    catch {
+        return '(无摘要)';
+    }
+}
+/** Read cwd from pi session JSONL first line (session event has cwd field). */
+function readCwdFromPiJsonl(filePath) {
+    const line = findJsonlLine(filePath, (l) => {
+        try {
+            const obj = JSON.parse(l);
+            return obj.type === 'session' && typeof obj.cwd === 'string' && !!obj.cwd;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!line)
+        return undefined;
+    try {
+        return JSON.parse(line).cwd;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Find the JSONL file path for a session by scanning the cwd's directory. */
+function findSessionFile(sessionId, cwd, sessionsDir) {
+    const dir = projectDirForCwd(cwd, sessionsDir);
+    try {
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+        for (const f of files) {
+            // pi filenames: <timestamp>_<uuid>.jsonl — match by sessionId (uuid) suffix
+            if (f.includes(sessionId)) {
+                return path.join(dir, f);
+            }
+        }
+    }
+    catch {
+        // dir doesn't exist
+    }
+    return null;
+}
+/**
+ * P2-6 + P2-5 first-pass scan: stream the file once via `scanJsonlLines`
+ * (no `string[]` materialized), parse each line exactly once, and collect
+ * all metadata needed by readSessionContent (usage, tailOffset, displayTitle).
+ * Does NOT retain parsed objects — the events tail is re-parsed separately
+ * by `extractPiEventsFromTail` so memory for both raw line strings and
+ * parsed objects is O(tail), not O(whole file).
+ *
+ * Mirrors claude's scalarScan (P2-2 + P2-5). Preserves the skill-signature
+ * compression (`<skill>…</skill>` → `skill:x`) for displayTitle and the
+ * "last turn" semantics for usage tokens.
+ */
+function piScalarScan(filePath) {
+    const acc = new UsageAccumulator();
+    let tailOffset = -1;
+    let lastUserText;
+    scanJsonlLines(filePath, (line, offset) => {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (obj.type === 'message') {
+            const msg = obj.message;
+            if (!msg)
+                return;
+            // usage aggregation (assistant only)
+            if (msg.role === 'assistant' && msg.usage) {
+                const u = msg.usage;
+                acc.add({
+                    input: u.input ?? 0,
+                    output: u.output ?? 0,
+                    cacheRead: u.cacheRead ?? 0,
+                    cacheCreation: u.cacheWrite ?? 0,
+                    total: u.totalTokens ?? 0,
+                });
+            }
+            // last user message offset + displayTitle. Record the byte offset
+            // where the tail should start: the beginning of the NEXT line after
+            // this user message.
+            if (msg.role === 'user') {
+                tailOffset = offset + Buffer.byteLength(line, 'utf-8') + 1;
+                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.
+                if (text)
+                    lastUserText = compressSkillInjection(text);
+            }
+        }
+        else if (obj.type === 'compaction') {
+            acc.bumpCompact();
+        }
+    });
+    return {
+        tailOffset,
+        usage: buildPiUsage(acc),
+        displayTitle: lastUserText
+            ? truncate(lastUserText, 200, { normalizeWhitespace: true })
+            : undefined,
+    };
+}
+/**
+ * Build the AgentSessionUsage from an accumulator, preserving pi's
+ * "last turn" semantics: inputTokens/outputTokens use the LAST turn's
+ * values, contextLength = last turn's context-window occupancy
+ * (input + cacheRead + cacheCreation, excludes output — review P2-8 unified
+ * contract across all five readers), cumulative = session-wide sum.
+ * Returns undefined when no usage data was observed.
+ */
+function buildPiUsage(acc) {
+    const t = acc.totals;
+    if (t.input + t.output === 0) {
+        return undefined;
+    }
+    const l = acc.last;
+    const contextLength = l.input + l.cacheRead + l.cacheCreation;
+    return {
+        inputTokens: l.input,
+        outputTokens: l.output,
+        contextLength,
+        compactCount: acc.compactCount > 0 ? acc.compactCount : undefined,
+        cacheReadTokens: l.cacheRead > 0 ? l.cacheRead : 0,
+        cacheCreationTokens: l.cacheCreation > 0 ? l.cacheCreation : 0,
+        totalTokens: l.total > 0 ? l.total : undefined,
+        // Cumulative (session-wide): sum of ALL runs in the jsonl file.
+        cumulativeTotalTokens: t.input + t.output + t.cacheRead + t.cacheCreation,
+        cumulativeInputTokens: t.input,
+        cumulativeOutputTokens: t.output,
+        cumulativeCacheReadTokens: t.cacheRead,
+        cumulativeCacheCreationTokens: t.cacheCreation,
+    };
+}
+/**
+ * P2-6 + P2-5 second-pass: extract content-block events from the tail
+ * (lines after the last user message), re-parsing only those lines.
+ * `tailLines` is already the tail-only slice (read via
+ * `readJsonlLinesFromOffset`), so both raw line-string memory and parsed-
+ * object memory are O(tail), not O(whole file) — P2-6 + P2-5.
+ */
+function extractPiEventsFromTail(tailLines) {
+    const events = [];
+    for (const line of tailLines) {
+        if (!line.trim())
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type !== 'message' || !obj.message)
+                continue;
+            const message = obj.message;
+            // Handle error messages: when stopReason is "error", content is empty
+            // but errorMessage has details
+            if (message.stopReason === 'error' && message.errorMessage) {
+                events.push({
+                    type: 'error',
+                    content: `❌ ${message.errorMessage}`,
+                    timestamp: obj.timestamp,
+                });
+                continue;
+            }
+            const blocks = extractContentBlocks(message.content, PI_MAPPING);
+            const role = message.role ?? 'unknown';
+            for (const block of blocks) {
+                events.push({ type: block.type, content: block.content, timestamp: obj.timestamp });
+            }
+            if (blocks.length === 0 && message.role) {
+                events.push({ type: role, content: `(${role} event)`, timestamp: obj.timestamp });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return events;
+}
+/**
+ * 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 class PiSessionReader {
+    piDir;
+    sessionsDir;
+    constructor(opts = {}) {
+        this.piDir = opts.piDir ?? defaultPiDir();
+        this.sessionsDir = path.join(this.piDir, 'sessions');
+    }
+    listSessions(cwd, opts) {
+        const limit = opts?.limit ?? 20;
+        const offset = Math.max(0, opts?.offset ?? 0);
+        // SCAN: filesystem is the source of truth for pi sessions.
+        const scanned = this.listSessionsByScan(cwd);
+        return {
+            sessions: scanned.slice(offset, offset + limit),
+            total: scanned.length,
+        };
+    }
+    getNewestSession(cwd) {
+        return this.listSessions(cwd, { limit: 1 }).sessions[0] ?? null;
+    }
+    readSessionContent(sessionId, cwd, opts) {
+        let filePath = null;
+        filePath = findSessionFile(sessionId, cwd, this.sessionsDir);
+        if (!filePath) {
+            return { events: [] };
+        }
+        // Verify cwd matches
+        const fileCwd = readCwdFromPiJsonl(filePath);
+        if (fileCwd && fileCwd !== cwd) {
+            return { events: [] };
+        }
+        // P2-5 + P2-6: First pass STREAMS the file once via `scanJsonlLines`
+        // (no `string[]` materialized), parsing each line once to collect
+        // scalars (usage, tailOffset, displayTitle) while retaining no parsed
+        // objects and no whole-file line array. The tailOffset is the byte
+        // offset where the tail begins (start of the line after the last user
+        // message). A second pass re-reads ONLY the tail from that offset via
+        // `readJsonlLinesFromOffset` and re-parses it for events — O(tail)
+        // memory for both raw line strings and parsed objects, instead of
+        // O(whole file).
+        //
+        // Parse ratio: ≈1.0–1.5× line count when a user message exists.
+        // When the session has NO user message, tailOffset stays -1 and the
+        // tail IS the whole file → scan(N) + tail(N) = 2.0× — the known
+        // asymptotic upper bound of the two-phase design.
+        const scan = piScalarScan(filePath);
+        const tailLines = readJsonlLinesFromOffset(filePath, scan.tailOffset >= 0 ? scan.tailOffset : 0);
+        const events = extractPiEventsFromTail(tailLines);
+        // 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: scan.usage,
+            displayTitle: scan.displayTitle,
+        };
+    }
+    isSessionActive(sessionId, cwd) {
+        const filePath = findSessionFile(sessionId, cwd, this.sessionsDir);
+        if (!filePath)
+            return false;
+        try {
+            const st = fs.statSync(filePath);
+            return Date.now() - st.mtimeMs < STALE_MS;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- Private helpers ---
+    listSessionsByScan(cwd) {
+        const cacheKey = `${this.sessionsDir}\u0000${cwd}`;
+        const cached = piListCache.get(cacheKey);
+        if (cached && Date.now() - cached.builtAt < PI_LIST_TTL_MS) {
+            return cached.sessions;
+        }
+        const dir = projectDirForCwd(cwd, this.sessionsDir);
+        let files;
+        try {
+            files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+        }
+        catch {
+            return [];
+        }
+        const sessions = [];
+        for (const f of files) {
+            const full = path.join(dir, f);
+            try {
+                const st = fs.statSync(full);
+                const fileCwd = readCwdFromPiJsonl(full);
+                if (fileCwd && fileCwd !== cwd)
+                    continue;
+                // Extract sessionId (UUID) from filename: <timestamp>_<uuid>.jsonl
+                // The timestamp and uuid are separated by '_', and neither contains '_'
+                // (timestamps use '-'/'T'/':', UUIDs use '-'). Take the last '_' segment.
+                const stem = f.replace('.jsonl', '');
+                const sessionId = stem.includes('_') ? stem.slice(stem.lastIndexOf('_') + 1) : stem;
+                sessions.push({
+                    sessionId,
+                    summary: truncate(summarizePiSession(full), 60, { normalizeWhitespace: true }),
+                    mtime: st.mtimeMs,
+                });
+            }
+            catch {
+                // skip
+            }
+        }
+        // Same-mtime ties: secondary key keeps the full order deterministic.
+        sessions.sort((a, b) => b.mtime - a.mtime || a.sessionId.localeCompare(b.sessionId));
+        piListCache.set(cacheKey, { builtAt: Date.now(), sessions });
+        // Bound the cache (map iteration order = insertion order).
+        if (piListCache.size > PI_LIST_MAX_ENTRIES) {
+            const oldest = piListCache.keys().next().value;
+            if (oldest !== undefined)
+                piListCache.delete(oldest);
+        }
+        return sessions;
+    }
+}
+//# sourceMappingURL=sessions.js.map

package/dist/session/registry.d.ts

@@ -0,0 +1,12 @@
+import type { AgentKind, AgentSessionReader } from '../runner/index.js';
+/**
+ * Registry of `AgentSessionReader` instances, keyed by `AgentKind`. Mirrors
+ * `AgentRegistry` but for session-history reads. `index.ts` registers one
+ * reader per available agent at startup; router/bridge look up readers here
+ * instead of importing `claude-sessions.ts` directly.
+ */
+export declare class SessionReaderRegistry {
+    private readonly readers;
+    register(kind: AgentKind, reader: AgentSessionReader): void;
+    get(kind: AgentKind): AgentSessionReader;
+}

package/dist/session/registry.js

@@ -0,0 +1,20 @@
+/**
+ * Registry of `AgentSessionReader` instances, keyed by `AgentKind`. Mirrors
+ * `AgentRegistry` but for session-history reads. `index.ts` registers one
+ * reader per available agent at startup; router/bridge look up readers here
+ * instead of importing `claude-sessions.ts` directly.
+ */
+export class SessionReaderRegistry {
+    readers = new Map();
+    register(kind, reader) {
+        this.readers.set(kind, reader);
+    }
+    get(kind) {
+        const reader = this.readers.get(kind);
+        if (!reader) {
+            throw new Error(`session reader not registered: ${kind}`);
+        }
+        return reader;
+    }
+}
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,86 @@
+import type { AgentKind } from '../runner/index.js';
+interface SessionEntry {
+    /** Session IDs per agent kind (Map for in-memory, plain object for persistence). */
+    sessions: Map<AgentKind, string>;
+    /** Previous session IDs per agent kind - stored when switching away, for potential restore. */
+    previousSessions: Map<AgentKind, string>;
+    /** Arrival baseline per agent kind - the session id the user was given when
+     * they last "arrived" at this agent via config.save switch ('' = cleared arrival). */
+    arrivalSessions: Map<AgentKind, string>;
+    /** Session actual cwd per agent (from system.init event.cwd; only claude may differ from cwd). */
+    sessionCwds: Map<AgentKind, string>;
+    cwd: string;
+}
+/**
+ * Per-user session store. Persists cwd + per-agent sessions to disk so that
+ * the last workspace AND the last-used sessionId per agent are restored after
+ * a bridge restart.
+ *
+ * Persistence strategy:
+ * - Persists `cwd`, `sessions` (per-agent sessionId), `previousSessions`
+ *   (parked restore slots for `/config` agent switching), and `arrivalSessions`
+ *   (arrival baseline; '' entries are meaningful and must survive restart).
+ * - Atomic write (temp + rename) to avoid truncated files on crash
+ * - Corrupt files are treated as empty (with a warning)
+ *
+ * P3.3: sessions is Map<AgentKind, sessionId> (one session per agent), allowing
+ * each agent to maintain its own session context when switching between agents.
+ */
+export declare class SessionStore {
+    private sessions;
+    private readonly persistPath?;
+    private readonly defaultAgent?;
+    /**
+     * 进程内会话代际（2026-08-09 /new 被在途 run init 写回撤销事故）：
+     * 每次「用户意图移动 session 指针」+1。system.init 写回通道不 bump。
+     * Bridge 在 run 启动时快照 epoch，init 写回前比较——不一致说明 /new、
+     * /cd、/resume 等在 run 在途时移动了指针，该 run 的写回是 stale 的，丢弃。
+     * 不持久化：重启后无在途 run，stale 写回不可能发生。
+     * 独立 Map 而非 SessionEntry 字段：entry 有 ~10 处整体重构点，字段易漏传。
+     */
+    private agentEpochs;
+    private userEpochs;
+    private static epochKey;
+    /** 当前代际 = user 级 + agent 级之和；任一级 bump 都会改变总和。 */
+    getSessionEpoch(userId: string, agent: AgentKind): number;
+    /** 用户意图移动了指定 agent 的 session 指针（/new、/resume、/config 切换）。 */
+    bumpSessionEpoch(userId: string, agent: AgentKind): void;
+    /** 用户意图移动了全部 agent 的 session 指针（/cd、/ws use 的 setCwd）。 */
+    private bumpUserEpoch;
+    constructor(persistPath?: string, defaultAgent?: AgentKind);
+    get(userId: string): SessionEntry | undefined;
+    set(userId: string, entry: SessionEntry): void;
+    delete(userId: string): void;
+    /** Clear sessionId for a specific agent, keeping cwd and other agent sessions */
+    clearSessionId(userId: string, agent?: AgentKind, opts?: {
+        clearSessionCwd?: boolean;
+    }): void;
+    /** Get previous sessionId for a specific agent (stored when switching away) */
+    getPreviousSessionId(userId: string, agent: AgentKind): string | undefined;
+    /** Set previous sessionId for a specific agent (for potential restore when switching back) */
+    setPreviousSessionId(userId: string, agent: AgentKind, sessionId: string): void;
+    /** Clear previous sessionId for a specific agent */
+    clearPreviousSessionId(userId: string, agent: AgentKind): void;
+    /** Get the arrival baseline sessionId for a specific agent ('' and missing → undefined) */
+    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;
+    /** 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 */
+    getCwd(userId: string): string | undefined;
+    /** Get sessionId for a specific agent, or undefined if no session or sessionId is empty */
+    getSessionId(userId: string, agent?: AgentKind): string | undefined;
+    /** Set sessionId for a specific agent, optionally with cwd */
+    setSessionId(userId: string, agent: AgentKind, sessionId: string, cwd?: string): void;
+    /** Set sessionId for a specific agent and cwd together */
+    setSessionIdAndCwd(userId: string, agent: AgentKind, sessionId: string, cwd: string, sessionCwd?: string): void;
+    /** Get sessionCwd for a specific agent, or undefined if not set */
+    getSessionCwd(userId: string, agent?: AgentKind): string | undefined;
+    /** Set sessionId and sessionCwd for a specific agent, without touching cwd */
+    setSessionIdAndSessionCwd(userId: string, agent: AgentKind, sessionId: string, sessionCwd: string): void;
+    /** Persisted format: only cwd per user (sessionId is process-scoped) */
+    private load;
+    private autoPersist;
+}
+export {};