@akira-tl/forgerelay 0.3.5 → 0.3.7

package/dist/workspace-store.js

@@ -1,13 +1,32 @@
 import { and, desc, eq } from "drizzle-orm";
 import { openDatabase } from "./db/client.js";
-import { workspaceConversationBindings, workspaceSessions, } from "./db/schema.js";
+import { workspaceContextDeliveries, workspaceConversationBindings, workspaceSessions, } from "./db/schema.js";
+const DEFAULT_TOUCH_FLUSH_INTERVAL_MS = 5 * 60 * 1_000;
 export class SqliteWorkspaceStore {
     database;
-    constructor(stateDir) {
+    now;
+    touchFlushTimer;
+    pendingSessionTouches = new Map();
+    pendingConversationTouches = new Map();
+    constructor(stateDir, options = {}) {
         this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        const touchFlushIntervalMs = options.touchFlushIntervalMs ?? DEFAULT_TOUCH_FLUSH_INTERVAL_MS;
+        if (!Number.isInteger(touchFlushIntervalMs) || touchFlushIntervalMs < 1) {
+            throw new Error("Workspace touch flush interval must be a positive integer.");
+        }
+        this.touchFlushTimer = setInterval(() => {
+            try {
+                this.flushTouches();
+            }
+            catch (error) {
+                console.warn(`ForgeRelay workspace touch flush failed: ${errorMessage(error)}`);
+            }
+        }, touchFlushIntervalMs);
+        this.touchFlushTimer.unref();
     }
     createSession(input) {
-        const now = new Date().toISOString();
+        const now = this.now().toISOString();
         const session = {
             id: input.id,
             root: input.root,
@@ -47,19 +66,18 @@ export class SqliteWorkspaceStore {
             .from(workspaceSessions)
             .where(eq(workspaceSessions.id, id))
             .get();
-        return row ? rowToWorkspaceSession(row) : undefined;
+        if (!row)
+            return undefined;
+        return applySessionTouch(rowToWorkspaceSession(row), this.pendingSessionTouches.get(id));
     }
     touchSession(id) {
-        this.database.db
-            .update(workspaceSessions)
-            .set({ lastUsedAt: new Date().toISOString() })
-            .where(eq(workspaceSessions.id, id))
-            .run();
+        this.pendingSessionTouches.set(id, this.now().toISOString());
     }
     setSessionStatus(id, status) {
+        this.pendingSessionTouches.delete(id);
         this.database.db
             .update(workspaceSessions)
-            .set({ status, lastUsedAt: new Date().toISOString() })
+            .set({ status, lastUsedAt: this.now().toISOString() })
             .where(eq(workspaceSessions.id, id))
             .run();
     }
@@ -77,9 +95,13 @@ export class SqliteWorkspaceStore {
             : conditions.length === 1
                 ? query.where(conditions[0]).all()
                 : query.where(and(...conditions)).all();
-        return rows.map(rowToWorkspaceSession);
+        return rows
+            .map(rowToWorkspaceSession)
+            .map((session) => applySessionTouch(session, this.pendingSessionTouches.get(session.id)))
+            .sort((left, right) => right.lastUsedAt.localeCompare(left.lastUsedAt));
     }
     deleteSession(id) {
+        this.pendingSessionTouches.delete(id);
         this.database.db
             .delete(workspaceSessions)
             .where(eq(workspaceSessions.id, id))
@@ -90,7 +112,8 @@ export class SqliteWorkspaceStore {
             .select()
             .from(workspaceConversationBindings)
             .all()
-            .map(rowToWorkspaceConversationBinding);
+            .map(rowToWorkspaceConversationBinding)
+            .map((binding) => applyConversationTouch(binding, this.pendingConversationTouches.get(conversationTouchKey(binding.conversationScopeId, binding.targetKey))?.lastUsedAt));
     }
     getConversationBinding(conversationScopeId, targetKey) {
         const row = this.database.db
@@ -98,10 +121,13 @@ export class SqliteWorkspaceStore {
             .from(workspaceConversationBindings)
             .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
             .get();
-        return row ? rowToWorkspaceConversationBinding(row) : undefined;
+        if (!row)
+            return undefined;
+        const binding = rowToWorkspaceConversationBinding(row);
+        return applyConversationTouch(binding, this.pendingConversationTouches.get(conversationTouchKey(conversationScopeId, targetKey))?.lastUsedAt);
     }
     setConversationBinding(input) {
-        const now = new Date().toISOString();
+        const now = this.now().toISOString();
         const row = this.database.db
             .insert(workspaceConversationBindings)
             .values({
@@ -126,28 +152,122 @@ export class SqliteWorkspaceStore {
         if (!row) {
             throw new Error("Conversation workspace binding upsert returned no row.");
         }
+        this.pendingConversationTouches.delete(conversationTouchKey(input.conversationScopeId, input.targetKey));
         return rowToWorkspaceConversationBinding(row);
     }
     touchConversationBinding(conversationScopeId, targetKey) {
-        this.database.db
-            .update(workspaceConversationBindings)
-            .set({ lastUsedAt: new Date().toISOString() })
-            .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
-            .run();
+        this.pendingConversationTouches.set(conversationTouchKey(conversationScopeId, targetKey), {
+            conversationScopeId,
+            targetKey,
+            lastUsedAt: this.now().toISOString(),
+        });
     }
     deleteConversationBinding(conversationScopeId, targetKey) {
+        this.pendingConversationTouches.delete(conversationTouchKey(conversationScopeId, targetKey));
         this.database.db
             .delete(workspaceConversationBindings)
             .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
             .run();
     }
+    listContextDeliveries() {
+        return this.database.db
+            .select()
+            .from(workspaceContextDeliveries)
+            .orderBy(desc(workspaceContextDeliveries.deliveredAt))
+            .all()
+            .map(rowToWorkspaceContextDelivery);
+    }
+    getContextDelivery(conversationScopeId, targetKey) {
+        const row = this.database.db
+            .select()
+            .from(workspaceContextDeliveries)
+            .where(and(eq(workspaceContextDeliveries.conversationScopeId, conversationScopeId), eq(workspaceContextDeliveries.targetKey, targetKey)))
+            .get();
+        return row ? rowToWorkspaceContextDelivery(row) : undefined;
+    }
+    setContextDelivery(input) {
+        const deliveredAt = new Date().toISOString();
+        const row = this.database.db
+            .insert(workspaceContextDeliveries)
+            .values({ ...input, deliveredAt })
+            .onConflictDoUpdate({
+            target: [
+                workspaceContextDeliveries.conversationScopeId,
+                workspaceContextDeliveries.targetKey,
+            ],
+            set: {
+                contextFingerprint: input.contextFingerprint,
+                deliveredAt,
+            },
+        })
+            .returning()
+            .get();
+        if (!row)
+            throw new Error("Workspace context delivery upsert returned no row.");
+        return rowToWorkspaceContextDelivery(row);
+    }
+    deleteContextDelivery(conversationScopeId, targetKey) {
+        this.database.db
+            .delete(workspaceContextDeliveries)
+            .where(and(eq(workspaceContextDeliveries.conversationScopeId, conversationScopeId), eq(workspaceContextDeliveries.targetKey, targetKey)))
+            .run();
+    }
+    get pendingTouchCount() {
+        return this.pendingSessionTouches.size + this.pendingConversationTouches.size;
+    }
+    flushTouches() {
+        if (this.pendingTouchCount === 0)
+            return;
+        const sessionTouches = [...this.pendingSessionTouches.entries()];
+        const conversationTouches = [...this.pendingConversationTouches.values()];
+        const updateSession = this.database.sqlite.prepare("UPDATE workspace_sessions SET last_used_at = ? WHERE id = ?");
+        const updateConversation = this.database.sqlite.prepare("UPDATE workspace_conversation_bindings SET last_used_at = ? WHERE conversation_scope_id = ? AND target_key = ?");
+        const flush = this.database.sqlite.transaction(() => {
+            for (const [workspaceId, lastUsedAt] of sessionTouches) {
+                updateSession.run(lastUsedAt, workspaceId);
+            }
+            for (const touch of conversationTouches) {
+                updateConversation.run(touch.lastUsedAt, touch.conversationScopeId, touch.targetKey);
+            }
+        });
+        flush();
+        for (const [workspaceId, lastUsedAt] of sessionTouches) {
+            if (this.pendingSessionTouches.get(workspaceId) === lastUsedAt) {
+                this.pendingSessionTouches.delete(workspaceId);
+            }
+        }
+        for (const touch of conversationTouches) {
+            const key = conversationTouchKey(touch.conversationScopeId, touch.targetKey);
+            if (this.pendingConversationTouches.get(key)?.lastUsedAt === touch.lastUsedAt) {
+                this.pendingConversationTouches.delete(key);
+            }
+        }
+    }
     close() {
-        this.database.close();
+        clearInterval(this.touchFlushTimer);
+        try {
+            this.flushTouches();
+        }
+        finally {
+            this.database.close();
+        }
     }
 }
 export function createWorkspaceStore(stateDir) {
     return new SqliteWorkspaceStore(stateDir);
 }
+function applySessionTouch(session, lastUsedAt) {
+    return lastUsedAt ? { ...session, lastUsedAt } : session;
+}
+function applyConversationTouch(binding, lastUsedAt) {
+    return lastUsedAt ? { ...binding, lastUsedAt } : binding;
+}
+function conversationTouchKey(conversationScopeId, targetKey) {
+    return JSON.stringify([conversationScopeId, targetKey]);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function rowToWorkspaceSession(row) {
     return {
         id: row.id,
@@ -173,3 +293,11 @@ function rowToWorkspaceConversationBinding(row) {
         lastUsedAt: row.lastUsedAt,
     };
 }
+function rowToWorkspaceContextDelivery(row) {
+    return {
+        conversationScopeId: row.conversationScopeId,
+        targetKey: row.targetKey,
+        contextFingerprint: row.contextFingerprint,
+        deliveredAt: row.deliveredAt,
+    };
+}