lark-remote 0.1.3 → 0.1.5

package/dist/runner/codex/argv.d.ts

@@ -5,7 +5,7 @@
  * - `approval_policy="never"` eliminates the approval handshake (root cause ①).
  * - Prompt goes via stdin (`-` flag) to avoid argv escaping issues.
  * - `--skip-git-repo-check`: lark-remote's cwd may not be a git repo.
- * - User's `~/.codex/config.toml` and AGENTS.md/CLAUDE.md rules are preserved
+ * - User's `~/.codex/config.toml` and project rules are preserved
  *   (no `--ignore-user-config` / `--ignore-rules`).
  */
 interface BuildCodexExecArgsInput {

package/dist/runner/codex/argv.js

@@ -5,7 +5,7 @@
  * - `approval_policy="never"` eliminates the approval handshake (root cause ①).
  * - Prompt goes via stdin (`-` flag) to avoid argv escaping issues.
  * - `--skip-git-repo-check`: lark-remote's cwd may not be a git repo.
- * - User's `~/.codex/config.toml` and AGENTS.md/CLAUDE.md rules are preserved
+ * - User's `~/.codex/config.toml` and project rules are preserved
  *   (no `--ignore-user-config` / `--ignore-rules`).
  */
 /**

package/dist/runner/common/runner-utils.d.ts

@@ -11,6 +11,18 @@ export declare function pipeAllStdio(): ('ignore' | 'pipe')[];
  * rather than argv.
  */
 export declare function endStdinWithPrompt(proc: ChildProcess, message: string): void;
+/**
+ * Build a synthetic system.init event for pre-spawn failure paths.
+ *
+ * When the runner exits before spawning a process (validateBeforeRun failure,
+ * ENOENT spawn failure), no real system.init arrives from stdout. Without a
+ * synthetic init, the bridge's pre-init result guard (§9.22) and the run-state
+ * reducer's sessionId check would silently drop the error result, leaving the
+ * card showing "输出流已结束，但未收到 result 事件" instead of the actual
+ * error message. The synthetic init satisfies both guards so the real error
+ * result is processed normally.
+ */
+export declare function syntheticInitEvent(sessionId?: string): AgentEvent;
 /**
  * Build a standardized auth/error result event for yield.
  *

package/dist/runner/common/runner-utils.js

@@ -46,6 +46,27 @@ export function endStdinWithPrompt(proc, message) {
         }
     }
 }
+/**
+ * Build a synthetic system.init event for pre-spawn failure paths.
+ *
+ * When the runner exits before spawning a process (validateBeforeRun failure,
+ * ENOENT spawn failure), no real system.init arrives from stdout. Without a
+ * synthetic init, the bridge's pre-init result guard (§9.22) and the run-state
+ * reducer's sessionId check would silently drop the error result, leaving the
+ * card showing "输出流已结束，但未收到 result 事件" instead of the actual
+ * error message. The synthetic init satisfies both guards so the real error
+ * result is processed normally.
+ */
+export function syntheticInitEvent(sessionId = '') {
+    return {
+        type: 'system',
+        subtype: 'init',
+        session_id: sessionId,
+        cwd: '',
+        model: '',
+        timestamp: new Date().toISOString(),
+    };
+}
 /**
  * Build a standardized auth/error result event for yield.
  *

package/dist/runner/common/spawning-runner.js

@@ -6,7 +6,7 @@ import { getLogger } from '../../logger/index.js';
 import { ProcessStopper } from './process-stopper.js';
 import { SpawnHeartbeat } from './spawn-heartbeat.js';
 import { createJSONLStream } from './jsonl-stream.js';
-import { authErrorEvent } from './runner-utils.js';
+import { authErrorEvent, syntheticInitEvent } from './runner-utils.js';
 import { DEFAULT_STOP_GRACE_MS } from '../../config/index.js';
 /**
  * Magic-number constants (Clean Code P3-1, G25 Replace Magic Numbers with
@@ -255,6 +255,11 @@ export class SpawningRunner {
         // Pre-spawn validation hook (e.g. codex API key check)
         const validationError = this.validateBeforeRun(opts);
         if (validationError) {
+            // §9.22: yield synthetic init so the bridge's pre-init result guard and
+            // the run-state reducer's sessionId check don't silently drop the error
+            // result. Without init, the card would show a generic "输出流已结束"
+            // instead of the specific validation error message.
+            yield syntheticInitEvent(opts.sessionId);
             yield validationError;
             return;
         }
@@ -287,6 +292,9 @@ export class SpawningRunner {
             // so the user is not misdiagnosed into reinstalling the binary.
             const baseMsg = `${this.binary} 命令不可用（未找到或不可执行），请检查是否已安装或在 PATH 中`;
             const msg = spawnErr ? `${baseMsg}：${spawnErr.message}` : baseMsg;
+            // §9.22: yield synthetic init before the error result so bridge/run-state
+            // guards don't silently drop it (same rationale as validateBeforeRun).
+            yield syntheticInitEvent(opts.sessionId);
             yield authErrorEvent(msg);
             return;
         }

package/dist/session/claude/session-index.d.ts

@@ -0,0 +1,93 @@
+import { type ContentBlockMapping } from '../common/content-blocks.js';
+export interface SessionIndexEntry {
+    sessionId: string;
+    path: string;
+    fingerprint: string;
+    mtimeMs: number;
+    summary: string;
+    cwdSet: Set<string>;
+}
+export interface SessionIndexOptions {
+    /** Minimum interval between refresh scans (ms). Default 5000. */
+    refreshIntervalMs?: number;
+}
+/** Claude-specific field-name mapping for content block extraction. */
+export declare const CLAUDE_MAPPING: ContentBlockMapping;
+/**
+ * Detect Claude CLI sub-agent completion notification text.
+ * Claude CLI injects a `type:"user"` record with string content starting
+ * with `<task-notification>` when a sub-agent (Agent tool) finishes.
+ * These must be excluded from displayTitle/summary — they are machine
+ * injections, not real user input. Primary criterion: extracted text
+ * starts with `<task-notification` (works for both string and array
+ * content since `extractText` is called first). Secondary (optional):
+ * `origin.kind === 'task-notification'` (not all CLI versions write it).
+ */
+export declare function isTaskNotificationText(text: string): boolean;
+/**
+ * Extract first text from a user message.
+ * Used by parseSessionJsonl and sessions.ts readSessionContent.
+ */
+export declare function extractText(content: unknown): string | null;
+export interface ParsedSession {
+    cwdSet: Set<string>;
+    summary: string;
+}
+/**
+ * Unified parser: single streaming scan of a JSONL file producing both
+ * the complete set of cwd values AND the first real user message summary.
+ * Replaces the split readCwdFromJsonl (first-cwd) + jsonlContainsCwd (any-cwd).
+ */
+export declare function parseSessionJsonl(filePath: string): ParsedSession;
+/**
+ * Build a fingerprint string from file stat metadata.
+ * Uses `size + mtimeNs + ctimeNs + dev + ino` (bigint stat).
+ * `size`/`mtime` are required; the rest are best-effort.
+ */
+export declare function buildFingerprint(filePath: string): string;
+/**
+ * In-memory session index with three query views:
+ *   byPath:      path → entry
+ *   bySessionId: sessionId → Set<path>
+ *   byCwd:       cwd → Set<path>
+ *
+ * Build once, refresh on demand (throttled). Single-file parse failure
+ * doesn't affect other files; readdir failure preserves old index.
+ */
+export declare class SessionIndex {
+    private readonly projectsDir;
+    private readonly refreshIntervalMs;
+    private readonly byPath;
+    private readonly bySessionId;
+    private readonly byCwd;
+    private lastRefreshAt;
+    private built;
+    /** Test-only: count of parseSessionJsonl calls since creation */
+    parseCount: number;
+    /** Test-only: count of directory scan operations */
+    scanCount: number;
+    constructor(projectsDir: string, opts?: SessionIndexOptions);
+    /** Whether a full scan has ever completed successfully (readdir succeeded). */
+    get isBuilt(): boolean;
+    build(): void;
+    refresh(): void;
+    listByCwd(cwd: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): SessionIndexEntry[];
+    /**
+     * Find a session entry by sessionId and cwd.
+     * Re-stats the file to verify fingerprint before returning (拍板 3):
+     *   - fingerprint unchanged → trust index cwdSet
+     *   - fingerprint changed → re-parse that one file, update index, re-check
+     * Returns undefined if not found or cwd doesn't match.
+     *
+     * Note: we re-stat ALL paths for the sessionId regardless of the old cwdSet,
+     * because a fingerprint change may have added the target cwd to the set.
+     */
+    findBySessionIdAndCwd(sessionId: string, cwd: string): SessionIndexEntry | undefined;
+    private fullScan;
+    private updateEntry;
+    private removeEntry;
+    private removeCrossRefs;
+}

package/dist/session/claude/session-index.js

@@ -0,0 +1,374 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { scanJsonlLines } from '../common/jsonl.js';
+import { extractContentBlocks } from '../common/content-blocks.js';
+import { truncate } from '../../card/card-shared.js';
+import { getLogger } from '../../logger/index.js';
+// ─── Claude content block mapping (shared with sessions.ts) ─
+/** Claude-specific field-name mapping for content block extraction. */
+export const CLAUDE_MAPPING = {
+    toolUseType: 'tool_use',
+    toolResultType: 'tool_result',
+    toolInputField: 'input',
+    toolErrorField: 'is_error',
+};
+/**
+ * Detect Claude CLI sub-agent completion notification text.
+ * Claude CLI injects a `type:"user"` record with string content starting
+ * with `<task-notification>` when a sub-agent (Agent tool) finishes.
+ * These must be excluded from displayTitle/summary — they are machine
+ * injections, not real user input. Primary criterion: extracted text
+ * starts with `<task-notification` (works for both string and array
+ * content since `extractText` is called first). Secondary (optional):
+ * `origin.kind === 'task-notification'` (not all CLI versions write it).
+ */
+export function isTaskNotificationText(text) {
+    return text.trimStart().startsWith('<task-notification');
+}
+/**
+ * Extract first text from a user message.
+ * Used by parseSessionJsonl and sessions.ts readSessionContent.
+ */
+export function extractText(content) {
+    if (typeof content === 'string' && content.trim()) {
+        return content.trim();
+    }
+    const blocks = extractContentBlocks(content, CLAUDE_MAPPING);
+    const textBlock = blocks.find((b) => b.type === 'text');
+    if (textBlock)
+        return textBlock.content;
+    return null;
+}
+/**
+ * Unified parser: single streaming scan of a JSONL file producing both
+ * the complete set of cwd values AND the first real user message summary.
+ * Replaces the split readCwdFromJsonl (first-cwd) + jsonlContainsCwd (any-cwd).
+ */
+export function parseSessionJsonl(filePath) {
+    const cwdSet = new Set();
+    let summary = '(无摘要)';
+    let foundSummary = false;
+    const ok = scanJsonlLines(filePath, (line) => {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        // Collect cwd values
+        if (typeof obj.cwd === 'string' && obj.cwd) {
+            cwdSet.add(obj.cwd);
+        }
+        // Find first real user message for summary (same logic as summarizeSession)
+        if (!foundSummary && obj.type === 'user' && !!obj.message) {
+            const msg = obj.message;
+            if (msg.content) {
+                const text = extractText(msg.content);
+                if (text && !isTaskNotificationText(text)) {
+                    summary = text;
+                    foundSummary = true;
+                }
+            }
+        }
+    });
+    // If file couldn't be opened, return empty result
+    if (!ok) {
+        return { cwdSet: new Set(), summary: '(无摘要)' };
+    }
+    return { cwdSet, summary };
+}
+// ─── buildFingerprint ───────────────────────────────────────
+/**
+ * Build a fingerprint string from file stat metadata.
+ * Uses `size + mtimeNs + ctimeNs + dev + ino` (bigint stat).
+ * `size`/`mtime` are required; the rest are best-effort.
+ */
+export function buildFingerprint(filePath) {
+    let st;
+    try {
+        st = fs.statSync(filePath, { bigint: true });
+    }
+    catch {
+        return '';
+    }
+    const parts = [String(st.size), String(st.mtimeNs)];
+    // ctimeNs, dev, ino: include if available
+    try {
+        parts.push(String(st.ctimeNs));
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        parts.push(String(st.dev));
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        parts.push(String(st.ino));
+    }
+    catch {
+        /* skip */
+    }
+    return parts.join('|');
+}
+// ─── SessionIndex ───────────────────────────────────────────
+/**
+ * In-memory session index with three query views:
+ *   byPath:      path → entry
+ *   bySessionId: sessionId → Set<path>
+ *   byCwd:       cwd → Set<path>
+ *
+ * Build once, refresh on demand (throttled). Single-file parse failure
+ * doesn't affect other files; readdir failure preserves old index.
+ */
+export class SessionIndex {
+    projectsDir;
+    refreshIntervalMs;
+    byPath = new Map();
+    bySessionId = new Map();
+    byCwd = new Map();
+    lastRefreshAt = 0;
+    built = false;
+    /** Test-only: count of parseSessionJsonl calls since creation */
+    parseCount = 0;
+    /** Test-only: count of directory scan operations */
+    scanCount = 0;
+    constructor(projectsDir, opts = {}) {
+        this.projectsDir = projectsDir;
+        this.refreshIntervalMs = opts.refreshIntervalMs ?? 5000;
+    }
+    /** Whether a full scan has ever completed successfully (readdir succeeded). */
+    get isBuilt() {
+        return this.built;
+    }
+    // ── Build (initial full scan) ───────────────────────────
+    build() {
+        this.scanCount++;
+        this.fullScan();
+        this.lastRefreshAt = Date.now();
+    }
+    // ── Refresh (throttled incremental) ─────────────────────
+    refresh() {
+        const now = Date.now();
+        if (now - this.lastRefreshAt < this.refreshIntervalMs) {
+            return; // throttled
+        }
+        this.scanCount++;
+        this.fullScan();
+        this.lastRefreshAt = now;
+    }
+    // ── Query: listByCwd ────────────────────────────────────
+    listByCwd(cwd, opts = {}) {
+        const paths = this.byCwd.get(cwd);
+        if (!paths || paths.size === 0)
+            return [];
+        // Gather entries, deduplicate by sessionId (keep mtime newest)
+        const byId = new Map();
+        for (const p of paths) {
+            const entry = this.byPath.get(p);
+            if (!entry)
+                continue;
+            const existing = byId.get(entry.sessionId);
+            if (!existing || entry.mtimeMs > existing.mtimeMs) {
+                byId.set(entry.sessionId, entry);
+            }
+        }
+        const sorted = [...byId.values()].sort((a, b) => b.mtimeMs - a.mtimeMs || a.sessionId.localeCompare(b.sessionId));
+        const offset = opts.offset ?? 0;
+        const limit = opts.limit;
+        const sliced = limit === undefined ? sorted.slice(offset) : sorted.slice(offset, offset + limit);
+        return sliced;
+    }
+    // ── Query: findBySessionIdAndCwd ────────────────────────
+    /**
+     * Find a session entry by sessionId and cwd.
+     * Re-stats the file to verify fingerprint before returning (拍板 3):
+     *   - fingerprint unchanged → trust index cwdSet
+     *   - fingerprint changed → re-parse that one file, update index, re-check
+     * Returns undefined if not found or cwd doesn't match.
+     *
+     * Note: we re-stat ALL paths for the sessionId regardless of the old cwdSet,
+     * because a fingerprint change may have added the target cwd to the set.
+     */
+    findBySessionIdAndCwd(sessionId, cwd) {
+        const paths = this.bySessionId.get(sessionId);
+        if (!paths || paths.size === 0)
+            return undefined;
+        for (const p of paths) {
+            const entry = this.byPath.get(p);
+            if (!entry)
+                continue;
+            // Re-stat to verify fingerprint (拍板 3)
+            const currentFp = buildFingerprint(p);
+            if (currentFp === '') {
+                // File disappeared — remove from index
+                this.removeEntry(p);
+                continue;
+            }
+            if (currentFp === entry.fingerprint) {
+                // Fingerprint matches → trust index
+                if (entry.cwdSet.has(cwd))
+                    return entry;
+                continue;
+            }
+            // Fingerprint changed → re-parse this single file
+            const parsed = parseSessionJsonl(p);
+            this.parseCount++;
+            try {
+                const st = fs.statSync(p, { bigint: true });
+                const updated = {
+                    sessionId: entry.sessionId,
+                    path: p,
+                    fingerprint: currentFp,
+                    mtimeMs: Number(st.mtimeMs),
+                    summary: truncate(parsed.summary, 60, { normalizeWhitespace: true }),
+                    cwdSet: parsed.cwdSet,
+                };
+                this.updateEntry(p, updated);
+                // Re-check cwd after update
+                if (updated.cwdSet.has(cwd))
+                    return updated;
+            }
+            catch {
+                // File gone
+                this.removeEntry(p);
+            }
+        }
+        return undefined;
+    }
+    // ── Internal: full scan ─────────────────────────────────
+    fullScan() {
+        let entries;
+        try {
+            entries = fs.readdirSync(this.projectsDir);
+        }
+        catch {
+            // readdir failure → preserve old index, degrade to fallback
+            getLogger().warn('[session-index] readdir failed, preserving old index');
+            return;
+        }
+        // readdir succeeded → the snapshot is authoritative for what we could read.
+        this.built = true;
+        const currentPaths = new Set();
+        for (const entry of entries) {
+            const subdir = path.join(this.projectsDir, entry);
+            let st;
+            try {
+                st = fs.statSync(subdir);
+                if (!st.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            let files;
+            try {
+                files = fs.readdirSync(subdir).filter((f) => f.endsWith('.jsonl'));
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                const fullPath = path.join(subdir, f);
+                currentPaths.add(fullPath);
+                // Check fingerprint
+                const fp = buildFingerprint(fullPath);
+                if (fp === '')
+                    continue; // can't stat, skip
+                const existing = this.byPath.get(fullPath);
+                if (existing && existing.fingerprint === fp) {
+                    // Unchanged, keep as-is
+                    continue;
+                }
+                // New file or fingerprint changed → parse
+                // Concurrent-write guard: stat before and after parse, compare fingerprints
+                const fpBefore = fp;
+                const parsed = parseSessionJsonl(fullPath);
+                this.parseCount++;
+                const fpAfter = buildFingerprint(fullPath);
+                if (fpBefore !== fpAfter) {
+                    // File was modified during parse → skip this round, retry next refresh
+                    getLogger().info(`[session-index] concurrent write detected for ${f}, skipping`);
+                    continue;
+                }
+                try {
+                    const fileStat = fs.statSync(fullPath, { bigint: true });
+                    const sessionId = f.slice(0, -'.jsonl'.length);
+                    const newEntry = {
+                        sessionId,
+                        path: fullPath,
+                        fingerprint: fpAfter,
+                        mtimeMs: Number(fileStat.mtimeMs),
+                        summary: truncate(parsed.summary, 60, { normalizeWhitespace: true }),
+                        cwdSet: parsed.cwdSet,
+                    };
+                    this.updateEntry(fullPath, newEntry);
+                }
+                catch (err) {
+                    getLogger().warn(`[session-index] skip ${f}: ${err.message}`);
+                }
+            }
+        }
+        // Remove entries for files that no longer exist
+        for (const p of [...this.byPath.keys()]) {
+            if (!currentPaths.has(p)) {
+                this.removeEntry(p);
+            }
+        }
+    }
+    // ── Internal: index mutation ────────────────────────────
+    updateEntry(filePath, entry) {
+        const old = this.byPath.get(filePath);
+        // Remove old entry's cross-references if it exists
+        if (old) {
+            this.removeCrossRefs(filePath, old);
+        }
+        // Set new entry
+        this.byPath.set(filePath, entry);
+        // bySessionId
+        let idPaths = this.bySessionId.get(entry.sessionId);
+        if (!idPaths) {
+            idPaths = new Set();
+            this.bySessionId.set(entry.sessionId, idPaths);
+        }
+        idPaths.add(filePath);
+        // byCwd
+        for (const cwd of entry.cwdSet) {
+            let cwdPaths = this.byCwd.get(cwd);
+            if (!cwdPaths) {
+                cwdPaths = new Set();
+                this.byCwd.set(cwd, cwdPaths);
+            }
+            cwdPaths.add(filePath);
+        }
+    }
+    removeEntry(filePath) {
+        const entry = this.byPath.get(filePath);
+        if (!entry)
+            return;
+        this.removeCrossRefs(filePath, entry);
+        this.byPath.delete(filePath);
+    }
+    removeCrossRefs(filePath, entry) {
+        // bySessionId
+        const idPaths = this.bySessionId.get(entry.sessionId);
+        if (idPaths) {
+            idPaths.delete(filePath);
+            if (idPaths.size === 0)
+                this.bySessionId.delete(entry.sessionId);
+        }
+        // byCwd
+        for (const cwd of entry.cwdSet) {
+            const cwdPaths = this.byCwd.get(cwd);
+            if (cwdPaths) {
+                cwdPaths.delete(filePath);
+                if (cwdPaths.size === 0)
+                    this.byCwd.delete(cwd);
+            }
+        }
+    }
+}
+//# sourceMappingURL=session-index.js.map

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

@@ -1,27 +1,9 @@
 import type { AgentSession, AgentSessionContentEvent, AgentSessionUsage } from '../../runner/index.js';
-/**
- * Read the FIRST cwd from a Claude session JSONL. Used for display and
- * diagnostics. Claude CLI writes the absolute (symlink-resolved) cwd on
- * every event that produces one; older versions wrote it once on init.
- * Returns the first non-empty value, or undefined if absent.
- *
- * For cwd GUARD checks (list/read), use `jsonlContainsCwd` which accepts
- * any matching cwd field (required for relocated sessions whose first cwd
- * is the pre-relocate path). The directory name under ~/.claude/projects/
- * is lossy (encodes `/` AND `_` as `-`), so it cannot be decoded back to
- * a real path. See regression 2026-06-21 /resume & /cd 路径错乱.
- */
-export declare function readCwdFromJsonl(filePath: string): string | undefined;
 /**
  * List Claude Code sessions for a given cwd, newest first. Each entry has
  * the sessionId (= jsonl filename stem), a one-line summary extracted from
  * the first user message, and the file mtime. Returns an empty array when
  * the project directory doesn't exist or no jsonl has a matching cwd field.
- *
- * We locate the directory via `projectDirForCwd` (lossy but OK for locating
- * a known cwd) and then **verify** each jsonl's cwd field matches. This
- * prevents collision: `disk_d/foo` and `disk-d/foo` both encode to the same
- * directory name, but only the matching cwd field is kept.
  */
 export declare function listClaudeSessions(cwd: string, opts?: {
     limit?: number;