@qwickapps/qwickbrain-proxy 1.0.2 → 1.1.0

package/src/lib/cache-manager.ts

@@ -1,30 +1,103 @@
-import { eq, and, lt, lte, sql } from 'drizzle-orm';
+import { eq, and, sql, desc } from 'drizzle-orm';
 import type { DB } from '../db/client.js';
 import { documents, memories } from '../db/schema.js';
 import type { Config } from '../types/config.js';
 
+// Critical document types - never evicted, not counted toward storage limit
+const CRITICAL_DOC_TYPES = ['workflow', 'rule', 'agent', 'template'];
+
 interface CachedItem<T> {
   data: T;
   cachedAt: Date;
-  expiresAt: Date;
   age: number; // seconds
-  isExpired: boolean;
 }
 
 export class CacheManager {
+  private maxDynamicCacheSize: number; // Storage limit for dynamic tier only (bytes)
+
   constructor(
     private db: DB,
     private config: Config['cache']
-  ) {}
+  ) {
+    // Default to 100MB if not configured
+    this.maxDynamicCacheSize = config.maxCacheSizeBytes || 100 * 1024 * 1024;
+  }
 
-  private getTTL(operation: string): number {
-    const ttlMap: Record<string, number> = {
-      get_workflow: this.config.ttl.workflows,
-      get_document: this.config.ttl.documents,
-      get_memory: this.config.ttl.memories,
-    };
+  /**
+   * Get current size of dynamic tier cache (excludes critical tier)
+   */
+  private async getDynamicCacheSize(): Promise<number> {
+    const result = await this.db
+      .select({ total: sql<number>`COALESCE(sum(${documents.sizeBytes}), 0) + COALESCE((SELECT sum(${memories.sizeBytes}) FROM ${memories}), 0)` })
+      .from(documents)
+      .where(eq(documents.isCritical, false));
+
+    return result[0]?.total || 0;
+  }
+
+  /**
+   * Evict LRU entries from dynamic tier to free up space
+   * NEVER touches critical tier
+   */
+  private async evictLRU(bytesToFree: number): Promise<void> {
+    let freed = 0;
+
+    // Evict from documents (dynamic tier only)
+    const docCandidates = await this.db
+      .select()
+      .from(documents)
+      .where(eq(documents.isCritical, false))
+      .orderBy(documents.lastAccessedAt) // ASC = oldest first
+      .limit(100);
+
+    for (const doc of docCandidates) {
+      if (freed >= bytesToFree) break;
+
+      await this.db.delete(documents).where(eq(documents.id, doc.id));
+      freed += doc.sizeBytes;
+      console.error(`LRU evicted document: ${doc.docType}:${doc.name} (${doc.sizeBytes} bytes)`);
+    }
+
+    // Evict from memories if needed
+    if (freed < bytesToFree) {
+      const memCandidates = await this.db
+        .select()
+        .from(memories)
+        .orderBy(memories.lastAccessedAt) // ASC = oldest first
+        .limit(100);
 
-    return ttlMap[operation] || 0;
+      for (const mem of memCandidates) {
+        if (freed >= bytesToFree) break;
+
+        await this.db.delete(memories).where(eq(memories.id, mem.id));
+        freed += mem.sizeBytes;
+        console.error(`LRU evicted memory: ${mem.name} (${mem.sizeBytes} bytes)`);
+      }
+    }
+
+    console.error(`LRU eviction complete: freed ${freed} bytes`);
+  }
+
+  /**
+   * Ensure sufficient cache space
+   * Critical items bypass this check
+   */
+  private async ensureCacheSize(requiredBytes: number, isCritical: boolean): Promise<void> {
+    // Critical files bypass storage limit check
+    if (isCritical) {
+      return;
+    }
+
+    // Only count dynamic tier toward storage limit
+    const currentSize = await this.getDynamicCacheSize();
+    if (currentSize + requiredBytes <= this.maxDynamicCacheSize) {
+      return;
+    }
+
+    // Evict LRU entries from dynamic tier only
+    const toEvict = currentSize + requiredBytes - this.maxDynamicCacheSize;
+    console.error(`Cache size limit reached: ${currentSize} + ${requiredBytes} > ${this.maxDynamicCacheSize}, evicting ${toEvict} bytes`);
+    await this.evictLRU(toEvict);
   }
 
   async getDocument(docType: string, name: string, project?: string): Promise<CachedItem<any> | null> {
@@ -46,10 +119,13 @@ export class CacheManager {
       return null;
     }
 
+    // Update last accessed timestamp for LRU tracking
     const now = new Date();
+    await this.db.update(documents)
+      .set({ lastAccessedAt: now })
+      .where(eq(documents.id, cached.id));
+
     const age = Math.floor((now.getTime() - cached.cachedAt.getTime()) / 1000);
-    // Fix: Compare timestamp values explicitly to avoid Date comparison issues
-    const isExpired = now.getTime() > cached.expiresAt.getTime();
 
     return {
       data: {
@@ -60,9 +136,7 @@ export class CacheManager {
         metadata: cached.metadata ? JSON.parse(cached.metadata) : {},
       },
       cachedAt: cached.cachedAt,
-      expiresAt: cached.expiresAt,
       age,
-      isExpired,
     };
   }
 
@@ -74,12 +148,12 @@ export class CacheManager {
     metadata?: Record<string, unknown>
   ): Promise<void> {
     const now = new Date();
-    const ttl = this.getTTL('get_document');
-    const expiresAt = new Date(now.getTime() + ttl * 1000);
-
-    // Use empty string instead of null for project to make unique constraint work
-    // SQLite treats NULL as distinct values in unique constraints
     const projectValue = project || '';
+    const isCritical = CRITICAL_DOC_TYPES.includes(docType);
+    const sizeBytes = Buffer.byteLength(content, 'utf8');
+
+    // Ensure space available (skips check if critical)
+    await this.ensureCacheSize(sizeBytes, isCritical);
 
     await this.db
       .insert(documents)
@@ -90,7 +164,9 @@ export class CacheManager {
         content,
         metadata: metadata ? JSON.stringify(metadata) : null,
         cachedAt: now,
-        expiresAt,
+        lastAccessedAt: now,
+        isCritical,
+        sizeBytes,
         synced: true,
       })
       .onConflictDoUpdate({
@@ -98,8 +174,8 @@ export class CacheManager {
         set: {
           content,
           metadata: metadata ? JSON.stringify(metadata) : null,
-          cachedAt: now,
-          expiresAt,
+          lastAccessedAt: now,
+          sizeBytes,
           synced: true,
         },
       });
@@ -123,10 +199,13 @@ export class CacheManager {
       return null;
     }
 
+    // Update last accessed timestamp for LRU tracking
     const now = new Date();
+    await this.db.update(memories)
+      .set({ lastAccessedAt: now })
+      .where(eq(memories.id, cached.id));
+
     const age = Math.floor((now.getTime() - cached.cachedAt.getTime()) / 1000);
-    // Fix: Compare timestamp values explicitly to avoid Date comparison issues
-    const isExpired = now.getTime() > cached.expiresAt.getTime();
 
     return {
       data: {
@@ -136,9 +215,7 @@ export class CacheManager {
         metadata: cached.metadata ? JSON.parse(cached.metadata) : {},
       },
       cachedAt: cached.cachedAt,
-      expiresAt: cached.expiresAt,
       age,
-      isExpired,
     };
   }
 
@@ -149,11 +226,11 @@ export class CacheManager {
     metadata?: Record<string, unknown>
   ): Promise<void> {
     const now = new Date();
-    const ttl = this.getTTL('get_memory');
-    const expiresAt = new Date(now.getTime() + ttl * 1000);
-
-    // Use empty string instead of null for project to make unique constraint work
     const projectValue = project || '';
+    const sizeBytes = Buffer.byteLength(content, 'utf8');
+
+    // Memories are always dynamic tier (not critical)
+    await this.ensureCacheSize(sizeBytes, false);
 
     await this.db
       .insert(memories)
@@ -163,7 +240,8 @@ export class CacheManager {
         content,
         metadata: metadata ? JSON.stringify(metadata) : null,
         cachedAt: now,
-        expiresAt,
+        lastAccessedAt: now,
+        sizeBytes,
         synced: true,
       })
       .onConflictDoUpdate({
@@ -171,31 +249,105 @@ export class CacheManager {
         set: {
           content,
           metadata: metadata ? JSON.stringify(metadata) : null,
-          cachedAt: now,
-          expiresAt,
+          lastAccessedAt: now,
+          sizeBytes,
           synced: true,
         },
       });
   }
 
-  async cleanupExpiredEntries(): Promise<{ documentsDeleted: number; memoriesDeleted: number }> {
-    const now = new Date();
+  /**
+   * Invalidate a document from cache (for SSE-based cache invalidation)
+   */
+  async invalidateDocument(docType: string, name: string, project?: string): Promise<void> {
+    const projectValue = project || '';
 
-    // Delete expired documents (use lte to include items expiring exactly now)
-    const deletedDocs = await this.db
+    await this.db
       .delete(documents)
-      .where(lte(documents.expiresAt, now))
-      .returning({ id: documents.id });
+      .where(
+        and(
+          eq(documents.docType, docType),
+          eq(documents.name, name),
+          eq(documents.project, projectValue)
+        )
+      );
+
+    console.error(`Cache invalidated: ${docType}:${name}`);
+  }
 
-    // Delete expired memories (use lte to include items expiring exactly now)
-    const deletedMems = await this.db
+  /**
+   * Invalidate a memory from cache (for SSE-based cache invalidation)
+   */
+  async invalidateMemory(name: string, project?: string): Promise<void> {
+    const projectValue = project || '';
+
+    await this.db
       .delete(memories)
-      .where(lte(memories.expiresAt, now))
-      .returning({ id: memories.id });
+      .where(
+        and(
+          eq(memories.name, name),
+          eq(memories.project, projectValue)
+        )
+      );
+
+    console.error(`Cache invalidated: memory:${name}`);
+  }
+
+  /**
+   * Get cache statistics
+   */
+  async getCacheStats(): Promise<{
+    criticalSize: number;
+    criticalCount: number;
+    dynamicSize: number;
+    dynamicCount: number;
+    totalSize: number;
+    totalCount: number;
+    memorySize: number;
+    memoryCount: number;
+  }> {
+    // Critical documents
+    const criticalResult = await this.db
+      .select({
+        size: sql<number>`COALESCE(sum(${documents.sizeBytes}), 0)`,
+        count: sql<number>`count(*)`
+      })
+      .from(documents)
+      .where(eq(documents.isCritical, true));
+
+    // Dynamic documents
+    const dynamicResult = await this.db
+      .select({
+        size: sql<number>`COALESCE(sum(${documents.sizeBytes}), 0)`,
+        count: sql<number>`count(*)`
+      })
+      .from(documents)
+      .where(eq(documents.isCritical, false));
+
+    // Memories
+    const memoryResult = await this.db
+      .select({
+        size: sql<number>`COALESCE(sum(${memories.sizeBytes}), 0)`,
+        count: sql<number>`count(*)`
+      })
+      .from(memories);
+
+    const criticalSize = criticalResult[0]?.size || 0;
+    const criticalCount = criticalResult[0]?.count || 0;
+    const dynamicSize = dynamicResult[0]?.size || 0;
+    const dynamicCount = dynamicResult[0]?.count || 0;
+    const memorySize = memoryResult[0]?.size || 0;
+    const memoryCount = memoryResult[0]?.count || 0;
 
     return {
-      documentsDeleted: deletedDocs.length,
-      memoriesDeleted: deletedMems.length,
+      criticalSize,
+      criticalCount,
+      dynamicSize: dynamicSize + memorySize,
+      dynamicCount: dynamicCount + memoryCount,
+      totalSize: criticalSize + dynamicSize + memorySize,
+      totalCount: criticalCount + dynamicCount + memoryCount,
+      memorySize,
+      memoryCount,
     };
   }
 }

package/src/lib/connection-manager.ts

@@ -3,6 +3,9 @@ import { ConnectionState } from '../types/mcp.js';
 import type { Config } from '../types/config.js';
 import type { QwickBrainClient } from './qwickbrain-client.js';
 
+// Dormant mode: long interval health check after giving up on reconnection
+const DORMANT_CHECK_INTERVAL = 300000; // 5 minutes
+
 export class ConnectionManager extends EventEmitter {
   private state: ConnectionState = 'disconnected';
   private reconnectAttempts = 0;
@@ -11,6 +14,7 @@ export class ConnectionManager extends EventEmitter {
   private qwickbrainClient: QwickBrainClient;
   private config: Config['connection'];
   private isStopped = false;
+  private isDormant = false;
   private executionLock: Promise<void> = Promise.resolve();
 
   constructor(qwickbrainClient: QwickBrainClient, config: Config['connection']) {
@@ -34,6 +38,7 @@ export class ConnectionManager extends EventEmitter {
 
   async start(): Promise<void> {
     this.isStopped = false;
+    this.isDormant = false;
     // Start health check in background (don't block server startup)
     this.healthCheck().catch(err => {
       console.error('Initial health check error:', err);
@@ -43,6 +48,7 @@ export class ConnectionManager extends EventEmitter {
 
   stop(): void {
     this.isStopped = true;
+    this.isDormant = false;
     if (this.healthCheckTimer) {
       clearTimeout(this.healthCheckTimer);
       this.healthCheckTimer = null;
@@ -62,25 +68,33 @@ export class ConnectionManager extends EventEmitter {
       const latencyMs = Date.now() - startTime;
 
       if (isHealthy) {
+        const wasDormant = this.isDormant;
+        this.isDormant = false;
         this.setState('connected');
         this.reconnectAttempts = 0;
         this.clearReconnectTimer();
         this.emit('connected', { latencyMs });
+
+        // If waking from dormant, switch back to normal health check interval
+        if (wasDormant) {
+          this.scheduleHealthCheck();
+        }
         return true;
       } else {
         throw new Error('Health check failed');
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.setState('disconnected');
-      this.emit('disconnected', { error: errorMessage });
-      this.scheduleReconnect();
+      if (!this.isDormant) {
+        this.setState('disconnected');
+        this.emit('disconnected', { error: errorMessage });
+        this.scheduleReconnect();
+      }
       return false;
     }
   }
 
   private scheduleHealthCheck(): void {
-    // Don't schedule if stopped
     if (this.isStopped) {
       return;
     }
@@ -89,13 +103,14 @@ export class ConnectionManager extends EventEmitter {
       clearTimeout(this.healthCheckTimer);
     }
 
+    const interval = this.isDormant ? DORMANT_CHECK_INTERVAL : this.config.healthCheckInterval;
+
     this.healthCheckTimer = setTimeout(async () => {
       await this.healthCheck();
-      // Check again before rescheduling to prevent leak after stop()
       if (!this.isStopped) {
         this.scheduleHealthCheck();
       }
-    }, this.config.healthCheckInterval);
+    }, interval);
   }
 
   private scheduleReconnect(): void {
@@ -104,8 +119,7 @@ export class ConnectionManager extends EventEmitter {
     }
 
     if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
-      this.setState('offline');
-      this.emit('maxReconnectAttemptsReached');
+      this.enterDormantMode();
       return;
     }
 
@@ -126,6 +140,51 @@ export class ConnectionManager extends EventEmitter {
     this.emit('reconnecting', { attempt: this.reconnectAttempts, delay });
   }
 
+  private enterDormantMode(): void {
+    this.isDormant = true;
+    this.setState('offline');
+    this.emit('dormant');
+
+    // Stop active health check and reconnect timers
+    if (this.healthCheckTimer) {
+      clearTimeout(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    // Schedule dormant-mode health check (5 min interval)
+    console.error(`Entering dormant mode. Will retry every ${DORMANT_CHECK_INTERVAL / 1000}s.`);
+    this.scheduleHealthCheck();
+  }
+
+  /**
+   * Wake from dormant mode and attempt immediate reconnection.
+   * Called when a tool is invoked and we need to try connecting again.
+   */
+  wakeUp(): void {
+    if (!this.isDormant || this.isStopped) {
+      return;
+    }
+
+    console.error('Waking from dormant mode for tool call...');
+    this.isDormant = false;
+    this.reconnectAttempts = 0;
+
+    // Clear dormant timer and do immediate health check
+    if (this.healthCheckTimer) {
+      clearTimeout(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+
+    this.healthCheck().catch(err => {
+      console.error('Wake-up health check error:', err);
+    });
+    this.scheduleHealthCheck();
+  }
+
   private clearReconnectTimer(): void {
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);