lark-remote 0.1.6 → 0.1.8

package/dist/session/codex/rollout-reader.js

@@ -11,12 +11,13 @@
  * ```
  *
  * Note: This handles the **rollout file format** (historical logging), NOT the
- * `codex exec --json` stdout format. Those are two different JSONL formats
- * (see design doc appendix B vs C).
+ * `codex exec --json` stdout format（已随 exec 模式移除）。
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import { readJsonlLines, findJsonlLine } from '../common/jsonl.js';
+import { STALE_MS } from '../common/constants.js';
+import { paginate, capEvents } from '../common/pagination.js';
 import { getLogger } from '../../logger/index.js';
 import { isRecord, stringValue } from '../../common/guards.js';
 import { resolveCodexHome } from '../../config/codex-config.js';
@@ -243,8 +244,6 @@ export function readCodexRollout(filePath) {
  */
 export function listCodexRollouts(opts = {}) {
     const codexHome = resolveCodexHome(opts.codexHome);
-    const limit = opts.limit ?? 20;
-    const offset = Math.max(0, opts.offset ?? 0);
     const filterCwd = opts.cwd;
     // Full index: every rollout file's session_meta + mtime, no early break.
     const index = getSessionIndex(codexHome);
@@ -263,8 +262,7 @@ export function listCodexRollouts(opts = {}) {
     // Same-mtime ties use filePath as a deterministic secondary key so index
     // rebuilds / walk order changes never reorder the page.
     matched.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
-    const total = matched.length;
-    const page = matched.slice(offset, offset + limit);
+    const { items: page, total } = paginate(matched, { limit: opts.limit, offset: opts.offset });
     // Full-parse only the page being returned (summary/usage).
     const entries = [];
     for (const item of page) {
@@ -317,22 +315,14 @@ export function readCodexSessionContent(sessionId, opts = {}) {
     }
     // Apply maxEvents cap: keep the LAST N events (most recent).
     // See function docstring for rationale.
-    // P2-7: maxEvents <= 0 returns [] — guards the `slice(-0) === slice(0)`
-    // full-array trap (no caller passes 0 today, but the contract must hold).
-    const events = opts.maxEvents !== undefined && opts.maxEvents > 0 && rollout.events.length > opts.maxEvents
-        ? rollout.events.slice(-opts.maxEvents)
-        : opts.maxEvents !== undefined && opts.maxEvents <= 0
-            ? []
-            : rollout.events;
+    const events = capEvents(rollout.events, opts.maxEvents);
     return {
         events,
         // displayTitle = LAST real user message (matches the
         // "最近输入" label). recap is undefined: codex has no
         // compact-summary concept, so never fake one from a user
         // message (was: firstUserMessage = injected project rules).
-        displayTitle: rollout.lastRealUserMessage
-            ? rollout.lastRealUserMessage.slice(0, 50)
-            : undefined,
+        displayTitle: rollout.lastRealUserMessage || undefined,
         recap: undefined,
         usage: rollout.usage,
     };
@@ -347,7 +337,9 @@ export function readCodexSessionContent(sessionId, opts = {}) {
  */
 export function isCodexSessionActive(sessionId, opts = {}) {
     const codexHome = resolveCodexHome(opts.codexHome);
-    const threshold = opts.activeThresholdMs ?? 10 * 60 * 1000; // 10 minutes default
+    // Unify with the other readers' 1-hour stale window (claude/pi/opencode/kimi
+    // all use STALE_MS). Previously codex used a divergent 10-minute default.
+    const threshold = opts.activeThresholdMs ?? STALE_MS;
     // P2-4: Use session index for direct file lookup + mtime check
     let index = getSessionIndex(codexHome);
     let entry = index.get(sessionId);
@@ -366,6 +358,11 @@ export function isCodexSessionActive(sessionId, opts = {}) {
     if (entry.isSubagent) {
         return false;
     }
+    // Cwd guard: when a cwd is provided, the session's working directory must
+    // match (align with claude/pi/opencode which validate cwd).
+    if (opts.cwd && entry.cwd !== opts.cwd) {
+        return false;
+    }
     // Re-stat to get fresh mtime (index may be up to INDEX_TTL_MS stale)
     try {
         const stat = fs.statSync(entry.filePath);

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

@@ -16,6 +16,6 @@ export declare class CodexSessionReader implements AgentSessionReader {
     readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
-    isSessionActive(sessionId: string, _cwd: string): boolean;
+    isSessionActive(sessionId: string, cwd: string): boolean;
 }
 export {};

package/dist/session/codex/sessions.js

@@ -34,8 +34,8 @@ export class CodexSessionReader {
             cwd,
         });
     }
-    isSessionActive(sessionId, _cwd) {
-        return isCodexSessionActive(sessionId, { codexHome: this.codexHome });
+    isSessionActive(sessionId, cwd) {
+        return isCodexSessionActive(sessionId, { codexHome: this.codexHome, cwd });
     }
 }
 //# sourceMappingURL=sessions.js.map

package/dist/session/common/content-blocks.d.ts

@@ -10,6 +10,13 @@ interface ContentBlock {
     type: 'text' | 'thinking' | 'tool_use' | 'tool_result';
     content: string;
 }
+/**
+ * Truncate a serialized tool-input string to 200 chars, collapsing newlines.
+ * Shared by content-block extraction and standalone wire-event readers (kimi
+ * tool.call) so the resume card never exceeds its 28KB budget on pathological
+ * args (e.g. whole-file writes / long prompts).
+ */
+export declare function truncateToolInput(inputStr: string): string;
 /** Maps agent-specific field names to the generic extraction logic. */
 export interface ContentBlockMapping {
     /** The `type` value that identifies a tool-use block (e.g. 'tool_use' or 'toolCall'). */

package/dist/session/common/content-blocks.js

@@ -5,6 +5,17 @@
  * tool_result blocks. The {@link ContentBlockMapping} type captures those
  * differences so a single implementation can serve all readers.
  */
+/**
+ * Truncate a serialized tool-input string to 200 chars, collapsing newlines.
+ * Shared by content-block extraction and standalone wire-event readers (kimi
+ * tool.call) so the resume card never exceeds its 28KB budget on pathological
+ * args (e.g. whole-file writes / long prompts).
+ */
+export function truncateToolInput(inputStr) {
+    if (inputStr.length <= 200)
+        return inputStr;
+    return inputStr.replace(/\n/g, ' ').slice(0, 197) + '...';
+}
 /**
  * Extract content blocks from a message content array.
  *
@@ -34,16 +45,9 @@ export function extractContentBlocks(content, mapping) {
         // tool_use block (parameterized type name + input field)
         if (p.type === mapping.toolUseType && typeof p.name === 'string') {
             const rawInput = p[mapping.toolInputField] ?? {};
-            const inputStr = JSON.stringify(rawInput, null, 2);
+            const inputStr = truncateToolInput(JSON.stringify(rawInput, null, 2));
             const label = `🔧 ${p.name}`;
-            let body;
-            if (inputStr.length > 200) {
-                body = inputStr.replace(/\n/g, ' ').slice(0, 197) + '...';
-            }
-            else {
-                body = inputStr;
-            }
-            blocks.push({ type: 'tool_use', content: `${label}: ${body}` });
+            blocks.push({ type: 'tool_use', content: `${label}: ${inputStr}` });
         }
         // tool_result block (parameterized type name + error field)
         if (p.type === mapping.toolResultType) {

package/dist/session/common/jsonl.d.ts

@@ -18,14 +18,7 @@ export declare function readLastJsonlLine(filePath: string): string | null;
  * Read the last N non-empty lines from a JSONL file using streaming reads.
  *
  * Unlike `readJsonlLines` (which materializes the entire file into a `string[]`),
- * this only retains the last `n` lines — memory is O(n), not O(whole file). The
- * file is still read front-to-back in chunks (no reverse seek), but earlier
- * lines are discarded as soon as the buffer exceeds `n`, so a multi-MB file
- * costs only ~`n` line strings of resident memory.
- *
- * Used by tail-only read paths (P2-5) such as `isSessionActive`, which only
- * need to inspect the file's tail (e.g. the last ~20 loop events) but were
- * previously full-slurping the whole wire log.
+ * this only retains the last `n` lines — memory is O(n), not O(whole file).
  *
  * @param filePath  Absolute path to a `.jsonl` file.
  * @param n         Maximum number of trailing non-empty lines to retain.
@@ -37,32 +30,23 @@ export declare function readLastNJsonlLines(filePath: string, n: number): string
  * Stream-scan a JSONL file once, invoking `onLine` for each non-empty line
  * with the line's raw string and its **starting byte offset** within the file.
  *
- * Unlike `readJsonlLines` this retains NOTHING — memory is O(chunk), not
- * O(whole file). The callback receives the byte offset so callers can record
- * where a line of interest (e.g. the last user message) begins, then re-read
- * only the tail from that offset via `readJsonlLinesFromOffset` (P2-5
- * byte-offset two-pass: full-file scalar scan without materializing a
- * `string[]`, then tail-only re-parse for events).
+ * Memory is O(chunk), not O(whole file). The callback receives the byte offset
+ * so callers can record where a line of interest begins, then re-read only the
+ * tail from that offset via `readJsonlLinesFromOffset`.
  *
  * @param filePath Absolute path to a `.jsonl` file.
- * @param onLine   Called for each non-empty line with `(line, offset)` where
- *                 `offset` is the byte offset of the line's first character.
+ * @param onLine   Called for each non-empty line with `(line, offset)`.
  * @returns `true` if the file was opened and scanned, `false` on open error.
  */
 export declare function scanJsonlLines(filePath: string, onLine: (line: string, offset: number) => void): boolean;
 /**
  * Read all non-empty lines starting from a byte `offset` in a JSONL file.
  *
- * Companion to `scanJsonlLines` for the P2-5 byte-offset two-pass pattern:
- * pass 1 records the offset where the tail begins (e.g. the byte right after
- * the last user message); pass 2 seeks there and reads/parses only the tail,
- * so raw line-string memory is O(tail) instead of O(whole file).
+ * Companion to `scanJsonlLines` for the byte-offset two-pass pattern.
  *
  * @param filePath Absolute path to a `.jsonl` file.
  * @param offset   Byte offset to seek to before reading. **Must fall on a line
- *                 boundary** (e.g. 0, or the start of the line after the last
- *                 user message as recorded by `scanJsonlLines`); a mid-line
- *                 offset will include a leading partial line.
+ *                 boundary**; a mid-line offset will include a leading partial line.
  * @returns Array of raw line strings from `offset` to EOF (empty lines
  *          excluded). Empty array on open/seek error or `offset` past EOF.
  */
@@ -71,7 +55,6 @@ export declare function readJsonlLinesFromOffset(filePath: string, offset: numbe
  * Read all non-empty lines from a JSONL file using streaming reads.
  *
  * @param filePath  Absolute path to a `.jsonl` file.
- * @param chunkSize Buffer size for each `fs.readSync` call (default 65536).
  * @returns Array of raw line strings (empty lines excluded).
  */
-export declare function readJsonlLines(filePath: string, chunkSize?: number): string[];
+export declare function readJsonlLines(filePath: string): string[];