sidekick-shared 0.18.3 → 0.18.5

package/dist/watchers/eventBridge.js

@@ -30,6 +30,7 @@ function toFollowEvents(event, providerId) {
         : undefined;
     const cost = usage?.reported_cost;
     const model = event.message?.model;
+    const rateLimits = event.rateLimits;
     switch (event.type) {
         case 'user': {
             const content = event.message?.content;
@@ -118,6 +119,24 @@ function toFollowEvents(event, providerId) {
             });
             break;
         }
+        case 'system': {
+            const text = extractTextContent(event.message?.content);
+            const label = event.message?.sourceLabel || event.message?.role || 'system';
+            const summary = text || (usage
+                ? `Tokens: ${usage.input_tokens || 0} in / ${usage.output_tokens || 0} out`
+                : label);
+            events.push({
+                providerId, type: 'system', timestamp: ts,
+                summary: label && text ? `${label}: ${text}` : summary,
+                tokens,
+                cacheTokens,
+                cost,
+                model,
+                rateLimits,
+                raw: event,
+            });
+            break;
+        }
         default: {
             // Handle 'result' and other types as system events
             const evtType = event.type;
@@ -136,6 +155,11 @@ function toFollowEvents(event, providerId) {
             e.permissionMode = permissionMode;
         }
     }
+    if (rateLimits) {
+        for (const e of events) {
+            e.rateLimits = e.rateLimits ?? rateLimits;
+        }
+    }
     return events;
 }
 // ── Helpers ──

package/dist/watchers/factory.d.ts

@@ -1,10 +1,10 @@
 /**
  * Factory for creating the correct session watcher by provider.
  */
-import type { SessionProvider } from '../providers/types';
+import type { SessionProviderBase } from '../providers/types';
 import type { SessionWatcher, SessionWatcherCallbacks } from './types';
 export interface CreateWatcherOptions {
-    provider: SessionProvider;
+    provider: SessionProviderBase;
     workspacePath: string;
     sessionId?: string;
     callbacks: SessionWatcherCallbacks;

package/dist/watchers/factory.js

@@ -40,6 +40,7 @@ exports.createWatcher = createWatcher;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const jsonlWatcher_1 = require("./jsonlWatcher");
+const providerReaderWatcher_1 = require("./providerReaderWatcher");
 const sqliteWatcher_1 = require("./sqliteWatcher");
 function getOpenCodeDataDir() {
     const xdg = process.env.XDG_DATA_HOME;
@@ -64,14 +65,15 @@ function createWatcher(options) {
     else {
         sessionPath = sessions[0]; // most recent
     }
-    const watcher = createWatcherForProvider(provider.id, sessionPath, callbacks);
+    const watcher = createWatcherForProvider(provider, sessionPath, callbacks);
     return { watcher, sessionPath };
 }
-function createWatcherForProvider(providerId, sessionPath, callbacks) {
-    switch (providerId) {
+function createWatcherForProvider(provider, sessionPath, callbacks) {
+    switch (provider.id) {
         case 'claude-code':
+            return new jsonlWatcher_1.JsonlSessionWatcher(provider.id, sessionPath, callbacks);
         case 'codex':
-            return new jsonlWatcher_1.JsonlSessionWatcher(providerId, sessionPath, callbacks);
+            return new providerReaderWatcher_1.ProviderReaderSessionWatcher(provider, sessionPath, callbacks);
         case 'opencode': {
             const dataDir = getOpenCodeDataDir();
             const dbPath = path.join(dataDir, 'opencode.db');
@@ -80,6 +82,6 @@ function createWatcherForProvider(providerId, sessionPath, callbacks) {
             return new sqliteWatcher_1.SqliteSessionWatcher(dbPath, sid, callbacks);
         }
         default:
-            throw new Error(`Unsupported provider: ${providerId}`);
+            throw new Error(`Unsupported provider: ${provider.id}`);
     }
 }

package/dist/watchers/providerReaderWatcher.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Session watcher backed by a provider SessionReader.
+ *
+ * This keeps live/replay FollowEvent consumers on the same canonical parser
+ * path used by provider-aware VS Code monitoring.
+ */
+import type { SessionProviderBase } from '../providers/types';
+import type { SessionWatcher, SessionWatcherCallbacks } from './types';
+export declare class ProviderReaderSessionWatcher implements SessionWatcher {
+    private readonly provider;
+    private readonly sessionPath;
+    private readonly callbacks;
+    private _isActive;
+    private fsWatcher;
+    private catchupTimer;
+    private debounceTimer;
+    private readonly reader;
+    constructor(provider: SessionProviderBase, sessionPath: string, callbacks: SessionWatcherCallbacks);
+    get isActive(): boolean;
+    seekTo(position: number): void;
+    getPosition(): number;
+    start(replay: boolean): void;
+    stop(): void;
+    private seekToEnd;
+    private debouncedRead;
+    private readNewEvents;
+}

package/dist/watchers/providerReaderWatcher.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Session watcher backed by a provider SessionReader.
+ *
+ * This keeps live/replay FollowEvent consumers on the same canonical parser
+ * path used by provider-aware VS Code monitoring.
+ */
+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.ProviderReaderSessionWatcher = void 0;
+const fs = __importStar(require("fs"));
+const eventBridge_1 = require("./eventBridge");
+const DEBOUNCE_MS = 100;
+const CATCHUP_INTERVAL_MS = 30_000;
+class ProviderReaderSessionWatcher {
+    provider;
+    sessionPath;
+    callbacks;
+    _isActive = false;
+    fsWatcher = null;
+    catchupTimer = null;
+    debounceTimer = null;
+    reader;
+    constructor(provider, sessionPath, callbacks) {
+        this.provider = provider;
+        this.sessionPath = sessionPath;
+        this.callbacks = callbacks;
+        this.reader = provider.createReader(sessionPath);
+    }
+    get isActive() { return this._isActive; }
+    seekTo(position) {
+        this.reader.seekTo(position);
+    }
+    getPosition() {
+        return this.reader.getPosition();
+    }
+    start(replay) {
+        if (this._isActive)
+            return;
+        this._isActive = true;
+        if (!replay) {
+            this.seekToEnd();
+        }
+        else {
+            this.readNewEvents();
+        }
+        try {
+            this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
+                this.debouncedRead();
+            });
+            this.fsWatcher.on('error', () => {
+                this.stop();
+            });
+        }
+        catch {
+            // fs.watch may be unavailable; polling still catches up.
+        }
+        this.catchupTimer = setInterval(() => {
+            if (this._isActive)
+                this.readNewEvents();
+        }, CATCHUP_INTERVAL_MS);
+    }
+    stop() {
+        if (!this._isActive)
+            return;
+        this._isActive = false;
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.fsWatcher) {
+            this.fsWatcher.close();
+            this.fsWatcher = null;
+        }
+        if (this.catchupTimer) {
+            clearInterval(this.catchupTimer);
+            this.catchupTimer = null;
+        }
+        this.reader.flush();
+    }
+    seekToEnd() {
+        try {
+            const stat = fs.statSync(this.sessionPath);
+            this.reader.seekTo(stat.size);
+        }
+        catch {
+            this.reader.reset();
+        }
+    }
+    debouncedRead() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.readNewEvents();
+        }, DEBOUNCE_MS);
+    }
+    readNewEvents() {
+        if (!this._isActive)
+            return;
+        try {
+            if (this.reader.wasTruncated()) {
+                this.reader.reset();
+            }
+            const events = this.reader.readNew();
+            for (const event of events) {
+                for (const followEvent of (0, eventBridge_1.toFollowEvents)(event, this.provider.id)) {
+                    this.callbacks.onEvent(followEvent);
+                }
+            }
+        }
+        catch (err) {
+            this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}
+exports.ProviderReaderSessionWatcher = ProviderReaderSessionWatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",