sidekick-shared 0.27.5 → 0.28.0

package/dist/watchers/jsonlTail.js

@@ -37,11 +37,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES = exports.DEFAULT_JSONL_TAIL_READ_BYTES = void 0;
 exports.createJsonlTail = createJsonlTail;
 const fs = __importStar(require("fs"));
+const fileHead_1 = require("../fileHead");
 const jsonl_1 = require("../parsers/jsonl");
 const DEFAULT_DEBOUNCE_MS = 100;
 const DEFAULT_CATCHUP_INTERVAL_MS = 30_000;
+/** Default bytes read from the file per chunk. */
+exports.DEFAULT_JSONL_TAIL_READ_BYTES = 1024 * 1024;
+/** Default longest line parsed; longer lines are skipped and reported. */
+exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES = 16 * 1024 * 1024;
 /** Skip old complete events while retaining an in-progress final line. */
 function lastCompleteLineOffset(filePath) {
     const fd = fs.openSync(filePath, 'r');
@@ -73,6 +79,15 @@ class JsonlTailReader {
     /** Resume-safe byte position ending immediately after a newline. */
     committedOffset;
     pendingBytes = Buffer.alloc(0);
+    /** Inside a line over `maxLineBytes`: drop bytes until its newline. */
+    skippingLine = false;
+    currentLine = { offset: 0, length: 0 };
+    /** Identity and prefix of the file the offsets refer to, once read. */
+    identity = null;
+    head = null;
+    lastMtimeMs = -1;
+    maxReadBytes;
+    maxLineBytes;
     fsWatcher = null;
     debounceTimer = null;
     catchupTimer = null;
@@ -82,10 +97,12 @@ class JsonlTailReader {
         this.options = options;
         this.readOffset = options.startOffset ?? 0;
         this.committedOffset = this.readOffset;
+        this.maxReadBytes = positiveInteger(options.maxReadBytes, exports.DEFAULT_JSONL_TAIL_READ_BYTES);
+        this.maxLineBytes = positiveInteger(options.maxLineBytes, exports.DEFAULT_JSONL_TAIL_MAX_LINE_BYTES);
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (event) => {
                 this.eventsInCurrentBatch += 1;
-                this.options.onEvent(event);
+                this.options.onEvent(event, this.currentLine);
             },
             onError: (error, line) => this.options.onError?.(error, line),
         }, { schema: options.schema });
@@ -137,36 +154,25 @@ class JsonlTailReader {
     readNow() {
         let fd = null;
         try {
-            const stat = fs.statSync(this.options.path);
-            if (stat.size < this.readOffset) {
-                this.readOffset = 0;
-                this.committedOffset = 0;
-                this.pendingBytes = Buffer.alloc(0);
-                this.parser.reset();
-            }
-            if (stat.size <= this.readOffset)
-                return;
-            const bytesToRead = stat.size - this.readOffset;
-            const buffer = Buffer.alloc(bytesToRead);
             fd = fs.openSync(this.options.path, 'r');
-            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.readOffset);
-            fs.closeSync(fd);
-            fd = null;
-            if (bytesRead <= 0)
+            const stat = fs.fstatSync(fd);
+            this.checkContinuity(fd, stat);
+            if (stat.size <= this.readOffset)
                 return;
-            this.readOffset += bytesRead;
             this.eventsInCurrentBatch = 0;
-            const combined = Buffer.concat([this.pendingBytes, buffer.subarray(0, bytesRead)]);
-            const lastNewline = combined.lastIndexOf(0x0a);
-            if (lastNewline >= 0) {
-                const completeLines = combined.subarray(0, lastNewline + 1);
-                this.pendingBytes = Buffer.from(combined.subarray(lastNewline + 1));
-                this.parser.processChunk(completeLines.toString('utf8'));
-            }
-            else {
-                this.pendingBytes = combined;
+            let bytesRead = 0;
+            const chunk = Buffer.alloc(Math.min(this.maxReadBytes, stat.size - this.readOffset));
+            while (this.readOffset < stat.size) {
+                const want = Math.min(chunk.length, stat.size - this.readOffset);
+                const count = fs.readSync(fd, chunk, 0, want, this.readOffset);
+                if (count <= 0)
+                    break;
+                this.consume(chunk.subarray(0, count), this.readOffset);
+                this.readOffset += count;
+                bytesRead += count;
             }
-            this.committedOffset = this.readOffset - this.pendingBytes.length;
+            if (bytesRead <= 0)
+                return;
             this.options.onBatchComplete?.({
                 bytesRead,
                 eventsRead: this.eventsInCurrentBatch,
@@ -174,6 +180,9 @@ class JsonlTailReader {
             });
         }
         catch (error) {
+            this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
             if (fd !== null) {
                 try {
                     fs.closeSync(fd);
@@ -182,9 +191,97 @@ class JsonlTailReader {
                     /* ignore close errors */
                 }
             }
-            this.options.onError?.(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * Starts over when the path now names another file, the file shrank, its
+     * first bytes changed, or the resume point no longer follows a newline.
+     */
+    checkContinuity(fd, stat) {
+        let reason = null;
+        if (this.identity && (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)) {
+            reason = 'replaced';
+        }
+        else if (stat.size < this.readOffset) {
+            reason = 'truncated';
+        }
+        if (reason === null && this.identity && stat.mtimeMs !== this.lastMtimeMs) {
+            const prefix = readAt(fd, 0, Math.min(fileHead_1.HEAD_BYTES, stat.size));
+            const before = this.committedOffset > 0 ? readAt(fd, this.committedOffset - 1, 1) : null;
+            if ((this.head && !(0, fileHead_1.headMatches)(this.head, prefix)) || (before && before[0] !== 0x0a)) {
+                reason = 'rewritten';
+            }
+        }
+        if (reason !== null)
+            this.reset(reason);
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        if (!this.head || this.head.bytes < Math.min(fileHead_1.HEAD_BYTES, stat.size)) {
+            this.head = (0, fileHead_1.fileHeadOf)(readAt(fd, 0, Math.min(fileHead_1.HEAD_BYTES, stat.size)));
+        }
+    }
+    reset(reason) {
+        const previousOffset = this.committedOffset;
+        this.readOffset = 0;
+        this.committedOffset = 0;
+        this.pendingBytes = Buffer.alloc(0);
+        this.skippingLine = false;
+        this.head = null;
+        this.parser.reset();
+        if (reason === 'replaced' && this.active) {
+            // fs.watch follows the old inode; watch the file now at the path.
+            this.fsWatcher?.close();
+            this.fsWatcher = null;
+            this.watchFile();
+        }
+        this.options.onReset?.({ reason, previousOffset });
+    }
+    /** Parses the complete lines in `bytes`, which start at file offset `position`. */
+    consume(bytes, position) {
+        let start = 0;
+        if (this.skippingLine) {
+            const newline = bytes.indexOf(0x0a);
+            if (newline < 0)
+                return;
+            this.skippingLine = false;
+            start = newline + 1;
+            this.committedOffset = position + start;
+        }
+        let lineStart = this.committedOffset;
+        let cursor = start;
+        for (;;) {
+            const newline = bytes.indexOf(0x0a, cursor);
+            if (newline < 0)
+                break;
+            const piece = bytes.subarray(cursor, newline);
+            const line = this.pendingBytes.length > 0 ? Buffer.concat([this.pendingBytes, piece]) : piece;
+            this.pendingBytes = Buffer.alloc(0);
+            const lineEnd = position + newline + 1;
+            if (line.length > this.maxLineBytes) {
+                this.reportOversized(lineStart, line.length);
+            }
+            else {
+                this.currentLine = { offset: lineStart, length: line.length };
+                this.parser.processChunk(line.toString('utf8') + '\n');
+            }
+            this.committedOffset = lineEnd;
+            lineStart = lineEnd;
+            cursor = newline + 1;
+        }
+        const rest = bytes.subarray(cursor);
+        if (rest.length === 0)
+            return;
+        if (this.pendingBytes.length + rest.length > this.maxLineBytes) {
+            this.reportOversized(lineStart, this.pendingBytes.length + rest.length);
+            this.pendingBytes = Buffer.alloc(0);
+            this.skippingLine = true;
+            return;
+        }
+        this.pendingBytes = Buffer.concat([this.pendingBytes, rest]);
+    }
+    reportOversized(offset, atLeast) {
+        this.options.onError?.(new Error(`JSONL line at byte ${offset} is over ${this.maxLineBytes} bytes (${atLeast} so far); skipped.`));
+    }
     getOffset() {
         return this.committedOffset;
     }
@@ -192,6 +289,7 @@ class JsonlTailReader {
         this.readOffset = Math.max(0, offset);
         this.committedOffset = this.readOffset;
         this.pendingBytes = Buffer.alloc(0);
+        this.skippingLine = false;
         this.parser.reset();
     }
     watchFile() {
@@ -216,3 +314,13 @@ class JsonlTailReader {
         this.debounceTimer = setTimeout(() => this.readNow(), debounceMs);
     }
 }
+function positiveInteger(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1
+        ? Math.floor(value)
+        : fallback;
+}
+function readAt(fd, position, length) {
+    const buffer = Buffer.alloc(length);
+    const count = length > 0 ? fs.readSync(fd, buffer, 0, length, position) : 0;
+    return buffer.subarray(0, count);
+}

package/dist/watchers/jsonlWatcher.js

@@ -240,6 +240,13 @@ class JsonlSessionWatcher {
             onEvent: (event) => this.handleRawEvent(event),
             onBatchComplete: () => this.callbacks.onBatchComplete?.(),
             onError: (error) => this.callbacks.onError?.(error),
+            // The file starts over, so per-file state from the old content must go too.
+            onReset: () => {
+                this.codexInPlanMode = false;
+                this.claudeUsageDeduper.reset();
+                this.codexPrevTotal = undefined;
+                this.callbacks.onReset?.();
+            },
         });
         this.tail.start();
     }

package/dist/watchers/providerReaderWatcher.js

@@ -137,6 +137,7 @@ class ProviderReaderSessionWatcher {
         try {
             if (this.reader.wasTruncated()) {
                 this.reader.reset();
+                this.callbacks.onReset?.();
             }
             const events = this.reader.readNew();
             for (const event of events) {

package/dist/watchers/types.d.ts

@@ -54,6 +54,12 @@ export interface SessionWatcherCallbacks {
     /** All events in this read have been delivered; the cursor can now be checkpointed. */
     onBatchComplete?: () => void;
     onError?: (error: Error) => void;
+    /**
+     * The session file was truncated, rewritten, or replaced, and its events
+     * are being delivered again from the beginning: discard anything built
+     * from earlier events.
+     */
+    onReset?: () => void;
 }
 export interface SessionWatcher {
     /** Start watching. If replay=true, emit existing events before streaming. */

package/dist/workspaceRoots.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Workspace-root expansion shared by the session readers: realpath each root
+ * and, optionally, add its git worktree siblings.
+ *
+ * @module workspaceRoots
+ */
+export interface ResolveWorkspaceRootsOptions {
+    /** Add the main checkout and every git worktree of each root. Default true. */
+    includeWorktrees?: boolean;
+}
+export interface ResolvedWorkspaceRoots {
+    /** Realpaths of the roots, after worktree expansion; scope checks use these. */
+    roots: string[];
+    /** The roots plus their unresolved spellings, for listing session files. */
+    listingRoots: string[];
+}
+/** Realpath of an absolute path, or null when it does not resolve. */
+export declare function realpathOrNull(input: string, cache?: Map<string, string | null>): string | null;
+/**
+ * Realpaths each absolute root and, by default, adds its main checkout and
+ * git worktree siblings. Relative and unresolvable roots are dropped.
+ */
+export declare function resolveWorkspaceRoots(workspacePaths: string[], options?: ResolveWorkspaceRootsOptions, realpaths?: Map<string, string | null>): ResolvedWorkspaceRoots;

package/dist/workspaceRoots.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Workspace-root expansion shared by the session readers: realpath each root
+ * and, optionally, add its git worktree siblings.
+ *
+ * @module workspaceRoots
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realpathOrNull = realpathOrNull;
+exports.resolveWorkspaceRoots = resolveWorkspaceRoots;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
+/** Realpath of an absolute path, or null when it does not resolve. */
+function realpathOrNull(input, cache = new Map()) {
+    const cached = cache.get(input);
+    if (cached !== undefined)
+        return cached;
+    let resolved = null;
+    try {
+        resolved = path.isAbsolute(input) ? fs.realpathSync.native(input) : null;
+    }
+    catch {
+        resolved = null;
+    }
+    cache.set(input, resolved);
+    return resolved;
+}
+/**
+ * Realpaths each absolute root and, by default, adds its main checkout and
+ * git worktree siblings. Relative and unresolvable roots are dropped.
+ */
+function resolveWorkspaceRoots(workspacePaths, options = {}, realpaths = new Map()) {
+    const includeWorktrees = options.includeWorktrees !== false;
+    const roots = new Set();
+    const listingRoots = new Set();
+    const add = (candidate) => {
+        const real = realpathOrNull(candidate, realpaths);
+        if (!real)
+            return;
+        roots.add(real);
+        listingRoots.add(real);
+        listingRoots.add(path.resolve(candidate));
+    };
+    for (const workspacePath of workspacePaths) {
+        if (typeof workspacePath !== 'string' || !path.isAbsolute(workspacePath))
+            continue;
+        add(workspacePath);
+        if (!includeWorktrees)
+            continue;
+        const real = realpathOrNull(workspacePath, realpaths);
+        if (!real)
+            continue;
+        const mainRepo = (0, sessionPathResolver_1.resolveWorktreeMainRepo)(real) ?? real;
+        add(mainRepo);
+        for (const sibling of (0, sessionPathResolver_1.discoverWorktreeSiblings)(mainRepo))
+            add(sibling);
+    }
+    return { roots: [...roots], listingRoots: [...listingRoots] };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.27.5",
+  "version": "0.28.0",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",
@@ -35,58 +35,75 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "module": "./dist/esm/index.js",
       "import": "./dist/index.js",
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     },
     "./browser": {
       "types": "./dist/browser.d.ts",
+      "module": "./dist/esm/browser.js",
       "import": "./dist/browser.js",
       "require": "./dist/browser.js",
       "default": "./dist/browser.js"
     },
     "./node": {
       "types": "./dist/node.d.ts",
+      "module": "./dist/esm/node.js",
       "import": "./dist/node.js",
       "require": "./dist/node.js",
       "default": "./dist/node.js"
     },
     "./schemas": {
       "types": "./dist/schemas/index.d.ts",
+      "module": "./dist/esm/schemas/index.js",
       "import": "./dist/schemas/index.js",
       "require": "./dist/schemas/index.js",
       "default": "./dist/schemas/index.js"
     },
     "./phrases": {
       "types": "./dist/phrases.d.ts",
+      "module": "./dist/esm/phrases.js",
       "import": "./dist/phrases.js",
       "require": "./dist/phrases.js",
       "default": "./dist/phrases.js"
     },
     "./modelContext": {
       "types": "./dist/modelContext.d.ts",
+      "module": "./dist/esm/modelContext.js",
       "import": "./dist/modelContext.js",
       "require": "./dist/modelContext.js",
       "default": "./dist/modelContext.js"
     },
     "./modelInfo": {
       "types": "./dist/modelInfo.d.ts",
+      "module": "./dist/esm/modelInfo.js",
       "import": "./dist/modelInfo.js",
       "require": "./dist/modelInfo.js",
       "default": "./dist/modelInfo.js"
     },
     "./formatting": {
       "types": "./dist/formatting.d.ts",
+      "module": "./dist/esm/formatting.js",
       "import": "./dist/formatting.js",
       "require": "./dist/formatting.js",
       "default": "./dist/formatting.js"
     },
     "./statusline": {
       "types": "./dist/statusline/index.d.ts",
+      "module": "./dist/esm/statusline/index.js",
       "import": "./dist/statusline/index.js",
       "require": "./dist/statusline/index.js",
       "default": "./dist/statusline/index.js"
     },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "module": "./dist/esm/testing/index.js",
+      "import": "./dist/testing/index.js",
+      "require": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    },
+    "./dist/esm/*": null,
     "./dist/*": {
       "types": "./dist/*.d.ts",
       "import": "./dist/*.js",
@@ -120,6 +137,9 @@
       ],
       "statusline": [
         "dist/statusline/index.d.ts"
+      ],
+      "testing": [
+        "dist/testing/index.d.ts"
       ]
     }
   },
@@ -133,7 +153,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.esm.json",
     "clean": "rm -rf dist",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",