sidekick-shared 0.23.0 → 0.24.0

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.24.0",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",