sidekick-shared 0.23.0 → 0.23.1

package/dist/watchers/jsonlTail.js

@@ -48,7 +48,11 @@ function createJsonlTail(options) {
 class JsonlTailReader {
     options;
     active = false;
-    offset;
+    /** Physical byte position already read from the file. */
+    readOffset;
+    /** Resume-safe byte position ending immediately after a newline. */
+    committedOffset;
+    pendingBytes = Buffer.alloc(0);
     fsWatcher = null;
     debounceTimer = null;
     catchupTimer = null;
@@ -56,7 +60,8 @@ class JsonlTailReader {
     parser;
     constructor(options) {
         this.options = options;
-        this.offset = options.startOffset ?? 0;
+        this.readOffset = options.startOffset ?? 0;
+        this.committedOffset = this.readOffset;
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (event) => {
                 this.eventsInCurrentBatch += 1;
@@ -74,11 +79,12 @@ class JsonlTailReader {
         this.active = true;
         if (this.options.startAtEnd && this.options.startOffset === undefined) {
             try {
-                this.offset = fs.statSync(this.options.path).size;
+                this.readOffset = fs.statSync(this.options.path).size;
             }
             catch {
-                this.offset = 0;
+                this.readOffset = 0;
             }
+            this.committedOffset = this.readOffset;
         }
         this.readNow();
         this.watchFile();
@@ -112,27 +118,39 @@ class JsonlTailReader {
         let fd = null;
         try {
             const stat = fs.statSync(this.options.path);
-            if (stat.size < this.offset) {
-                this.offset = 0;
+            if (stat.size < this.readOffset) {
+                this.readOffset = 0;
+                this.committedOffset = 0;
+                this.pendingBytes = Buffer.alloc(0);
                 this.parser.reset();
             }
-            if (stat.size <= this.offset)
+            if (stat.size <= this.readOffset)
                 return;
-            const bytesToRead = stat.size - this.offset;
+            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.offset);
+            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.readOffset);
             fs.closeSync(fd);
             fd = null;
             if (bytesRead <= 0)
                 return;
-            this.offset += bytesRead;
+            this.readOffset += bytesRead;
             this.eventsInCurrentBatch = 0;
-            this.parser.processChunk(buffer.toString('utf-8', 0, bytesRead));
+            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;
+            }
+            this.committedOffset = this.readOffset - this.pendingBytes.length;
             this.options.onBatchComplete?.({
                 bytesRead,
                 eventsRead: this.eventsInCurrentBatch,
-                offset: this.offset,
+                offset: this.committedOffset,
             });
         }
         catch (error) {
@@ -148,10 +166,12 @@ class JsonlTailReader {
         }
     }
     getOffset() {
-        return this.offset;
+        return this.committedOffset;
     }
     seekTo(offset) {
-        this.offset = Math.max(0, offset);
+        this.readOffset = Math.max(0, offset);
+        this.committedOffset = this.readOffset;
+        this.pendingBytes = Buffer.alloc(0);
         this.parser.reset();
     }
     watchFile() {

package/dist/watchers/jsonlWatcher.js

@@ -274,9 +274,11 @@ class JsonlSessionWatcher {
             this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', () => {
-                // File may have been deleted; stop gracefully
-                this.stop();
+            this.fsWatcher.on('error', (error) => {
+                // Degrade to catch-up polling without killing the live session.
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.callbacks.onError?.(error);
             });
         }
         catch {

package/dist/watchers/providerReaderWatcher.js

@@ -82,8 +82,10 @@ class ProviderReaderSessionWatcher {
             this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', () => {
-                this.stop();
+            this.fsWatcher.on('error', (error) => {
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.callbacks.onError?.(error);
             });
         }
         catch {

package/dist/watchers/sqliteWatcher.d.ts

@@ -7,6 +7,8 @@ export declare class SqliteSessionWatcher implements SessionWatcher {
     private _isActive;
     private lastMessageTime;
     private lastPartTime;
+    private seenMessageVersions;
+    private seenPartVersions;
     private fsWatcher;
     private walWatcher;
     private pollTimer;

package/dist/watchers/sqliteWatcher.js

@@ -164,6 +164,8 @@ class SqliteSessionWatcher {
     _isActive = false;
     lastMessageTime = 0;
     lastPartTime = 0;
+    seenMessageVersions = new Map();
+    seenPartVersions = new Map();
     fsWatcher = null;
     walWatcher = null;
     pollTimer = null;
@@ -185,6 +187,8 @@ class SqliteSessionWatcher {
     seekTo(position) {
         this.lastMessageTime = position;
         this.lastPartTime = position;
+        this.seenMessageVersions.clear();
+        this.seenPartVersions.clear();
     }
     /** Get the current cursor position (max timestamp seen). */
     getPosition() {
@@ -266,38 +270,47 @@ class SqliteSessionWatcher {
         }, DEBOUNCE_MS);
     }
     skipToEnd() {
-        const messages = this.db.getMessagesForSession(this.sessionId);
-        const parts = this.db.getPartsForSession(this.sessionId);
-        if (messages.length > 0) {
-            this.lastMessageTime = Math.max(...messages.map((m) => m.time_created));
+        this.lastMessageTime = this.db.getLatestMessageTimeUpdated(this.sessionId);
+        this.lastPartTime = this.db.getLatestPartTimeUpdated(this.sessionId);
+        if (this.lastMessageTime > 0) {
+            for (const message of this.db.getMessagesNewerThan(this.sessionId, this.lastMessageTime - 1)) {
+                this.seenMessageVersions.set(message.id, `${message.time_updated}:${message.data}`);
+            }
         }
-        if (parts.length > 0) {
-            this.lastPartTime = Math.max(...parts.map((p) => p.time_created));
+        if (this.lastPartTime > 0) {
+            for (const part of this.db.getPartsNewerThan(this.sessionId, this.lastPartTime - 1)) {
+                this.seenPartVersions.set(part.id, `${part.time_updated}:${part.data}`);
+            }
         }
     }
     pollNewData() {
         if (!this._isActive)
             return;
         try {
-            const messages = this.db.getMessagesForSession(this.sessionId);
-            const parts = this.db.getPartsForSession(this.sessionId);
+            // Query incrementally by update time. Subtracting one millisecond lets us
+            // see distinct rows committed at the cursor timestamp; version maps
+            // suppress rows whose id/data have already been emitted.
+            const messages = this.db.getMessagesNewerThan(this.sessionId, Math.max(-1, this.lastMessageTime - 1));
+            const parts = this.db.getPartsNewerThan(this.sessionId, Math.max(-1, this.lastPartTime - 1));
             // Emit new messages
-            const newMessages = messages.filter((m) => m.time_created > this.lastMessageTime);
+            const newMessages = messages.filter((message) => this.seenMessageVersions.get(message.id) !== `${message.time_updated}:${message.data}`);
             for (const msg of newMessages) {
                 const events = normalizeMessage(msg);
                 for (const e of events)
                     this.callbacks.onEvent(e);
-                if (msg.time_created > this.lastMessageTime)
-                    this.lastMessageTime = msg.time_created;
+                this.seenMessageVersions.set(msg.id, `${msg.time_updated}:${msg.data}`);
+                if (msg.time_updated > this.lastMessageTime)
+                    this.lastMessageTime = msg.time_updated;
             }
             // Emit new parts
-            const newParts = parts.filter((p) => p.time_created > this.lastPartTime);
+            const newParts = parts.filter((part) => this.seenPartVersions.get(part.id) !== `${part.time_updated}:${part.data}`);
             for (const part of newParts) {
                 const events = normalizePart(part);
                 for (const e of events)
                     this.callbacks.onEvent(e);
-                if (part.time_created > this.lastPartTime)
-                    this.lastPartTime = part.time_created;
+                this.seenPartVersions.set(part.id, `${part.time_updated}:${part.data}`);
+                if (part.time_updated > this.lastPartTime)
+                    this.lastPartTime = part.time_updated;
             }
         }
         catch (err) {

package/dist/writers/atomic.js

@@ -39,17 +39,53 @@ exports.updateJsonStoreAtomic = updateJsonStoreAtomic;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const LOCK_STALE_MS = 10_000;
+async function syncDirectory(directory) {
+    let handle;
+    try {
+        handle = await fs.promises.open(directory, 'r');
+        await handle.sync();
+    }
+    catch (error) {
+        const code = error.code;
+        if (!['EISDIR', 'EINVAL', 'ENOSYS', 'EPERM', 'EACCES'].includes(code ?? ''))
+            throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function syncDirectorySync(directory) {
+    let descriptor;
+    try {
+        descriptor = fs.openSync(directory, 'r');
+        fs.fsyncSync(descriptor);
+    }
+    catch (error) {
+        const code = error.code;
+        if (!['EISDIR', 'EINVAL', 'ENOSYS', 'EPERM', 'EACCES'].includes(code ?? ''))
+            throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
+}
 async function atomicWriteJson(filePath, value) {
     await fs.promises.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+    let handle;
     try {
-        await fs.promises.writeFile(tempPath, JSON.stringify(value, null, 2), {
-            encoding: 'utf8',
-            mode: 0o600,
-        });
+        handle = await fs.promises.open(tempPath, 'wx', 0o600);
+        await handle.writeFile(JSON.stringify(value, null, 2), 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
         await fs.promises.rename(tempPath, filePath);
+        await syncDirectory(path.dirname(filePath));
     }
     catch (error) {
+        await handle?.close().catch(() => undefined);
         await fs.promises.rm(tempPath, { force: true }).catch(() => undefined);
         throw error;
     }
@@ -57,11 +93,19 @@ async function atomicWriteJson(filePath, value) {
 function atomicWriteJsonSync(filePath, value) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+    let descriptor;
     try {
-        fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { encoding: 'utf8', mode: 0o600 });
+        descriptor = fs.openSync(tempPath, 'wx', 0o600);
+        fs.writeFileSync(descriptor, JSON.stringify(value, null, 2), { encoding: 'utf8' });
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
         fs.renameSync(tempPath, filePath);
+        syncDirectorySync(path.dirname(filePath));
     }
     catch (error) {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
         fs.rmSync(tempPath, { force: true });
         throw error;
     }
@@ -73,34 +117,65 @@ async function updateJsonStoreAtomic(filePath, createEmpty, update) {
     const lock = await acquireLock(lockPath);
     try {
         let latest = createEmpty();
+        let raw;
         try {
-            latest = JSON.parse(await fs.promises.readFile(filePath, 'utf8'));
+            raw = await fs.promises.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
         }
-        catch {
-            // Missing/malformed stores start from the schema-correct empty value.
+        if (raw !== undefined) {
+            try {
+                latest = JSON.parse(raw);
+            }
+            catch {
+                const corruptPath = `${filePath}.corrupt-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+                await fs.promises.rename(filePath, corruptPath);
+            }
         }
         const next = await update(latest);
         await atomicWriteJson(filePath, next);
         return next;
     }
     finally {
-        await lock.close().catch(() => undefined);
-        await fs.promises.rm(lockPath, { force: true }).catch(() => undefined);
+        await releaseLock(lockPath, lock);
     }
 }
 async function acquireLock(lockPath) {
     const deadline = Date.now() + 3000;
     while (true) {
         try {
-            return await fs.promises.open(lockPath, 'wx', 0o600);
+            const handle = await fs.promises.open(lockPath, 'wx', 0o600);
+            const token = `${process.pid}:${crypto.randomBytes(16).toString('hex')}`;
+            await handle.writeFile(token, 'utf8');
+            await handle.sync();
+            const heartbeat = setInterval(() => {
+                fs.promises.utimes(lockPath, new Date(), new Date()).catch(() => undefined);
+            }, Math.floor(LOCK_STALE_MS / 3));
+            heartbeat.unref();
+            return { handle, token, heartbeat };
         }
         catch (error) {
             if (error.code !== 'EEXIST')
                 throw error;
             try {
                 const stat = await fs.promises.stat(lockPath);
-                if (Date.now() - stat.mtimeMs > 10_000)
-                    await fs.promises.rm(lockPath, { force: true });
+                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                    const owner = await fs.promises.readFile(lockPath, 'utf8').catch(() => '');
+                    const ownerPid = Number.parseInt(owner.split(':', 1)[0], 10);
+                    let ownerAlive = Number.isInteger(ownerPid) && ownerPid > 0;
+                    if (ownerAlive) {
+                        try {
+                            process.kill(ownerPid, 0);
+                        }
+                        catch (ownerError) {
+                            ownerAlive = ownerError.code === 'EPERM';
+                        }
+                    }
+                    if (!ownerAlive)
+                        await fs.promises.rm(lockPath, { force: true });
+                }
             }
             catch {
                 // The other writer released between checks.
@@ -111,3 +186,15 @@ async function acquireLock(lockPath) {
         }
     }
 }
+async function releaseLock(lockPath, lock) {
+    clearInterval(lock.heartbeat);
+    await lock.handle.close().catch(() => undefined);
+    try {
+        const currentToken = await fs.promises.readFile(lockPath, 'utf8');
+        if (currentToken === lock.token)
+            await fs.promises.rm(lockPath, { force: true });
+    }
+    catch {
+        // The lock was already released or replaced; never delete another owner's lock.
+    }
+}

package/dist/zaiQuotaWatcher.js

@@ -169,6 +169,12 @@ class ZaiQuotaWatcher {
     }
     recomputeAndEmit() {
         const nowMs = this.now();
+        if (this.lastError?.resetsAt) {
+            const resetsAt = Date.parse(this.lastError.resetsAt);
+            if (Number.isFinite(resetsAt) && resetsAt <= nowMs) {
+                this.lastError = null;
+            }
+        }
         const accumulated = (0, zaiQuota_1.accumulateZaiUsage)(this.turns, nowMs);
         const tier = this.resolveTier(this.tier, accumulated);
         const state = accumulated.fiveHourTurns > 0 || accumulated.weeklyTurns > 0

package/package.json

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