Update stateManager.js

stateManager.js

@@ -1,31 +1,106 @@
+import admin from 'firebase-admin';
+
+// Initialize Firebase (Assuming it's initialized in server.js, but we need the ref here)
+// We will rely on server.js to initialize the app, or we can lazy-load the db ref.
+let db = null;
+
+// This function allows server.js to pass the initialized DB instance
+export const initDB = (firebaseDB) => {
+    db = firebaseDB;
+};
+
 const activeProjects = new Map();
 
 export const StateManager = {
+  /**
+   * GET PROJECT
+   * Strategy: Memory First -> DB Fallback -> Null
+   */
   getProject: async (projectId) => {
-    if (activeProjects.has(projectId)) return activeProjects.get(projectId);
+    // 1. Try Memory
+    if (activeProjects.has(projectId)) {
+        return activeProjects.get(projectId);
+    }
+
+    // 2. Try Firebase (Hydration)
+    if (db) {
+        try {
+            console.log(`[StateManager] 🟡 Hydrating project ${projectId} from DB...`);
+            const snapshot = await db.ref(`projects/${projectId}`).once('value');
+            if (snapshot.exists()) {
+                const projectData = snapshot.val();
+                
+                // Ensure arrays exist (Firebase doesn't store empty arrays)
+                if (!projectData.commandQueue) projectData.commandQueue = [];
+                if (!projectData.workerHistory) projectData.workerHistory = [];
+                if (!projectData.pmHistory) projectData.pmHistory = [];
+                
+                // Load into Memory
+                activeProjects.set(projectId, projectData);
+                console.log(`[StateManager] 🟢 Project ${projectId} hydrated.`);
+                return projectData;
+            }
+        } catch (err) {
+            console.error(`[StateManager] Error reading DB for ${projectId}:`, err);
+        }
+    }
+
     return null; 
   },
 
+  /**
+   * UPDATE PROJECT
+   * Strategy: Update Memory -> Async Write to DB
+   */
   updateProject: async (projectId, data) => {
-    const current = activeProjects.get(projectId) || { 
-      commandQueue: [], 
-      workerHistory: [],
-      pmHistory: [],
-      failureCount: 0 
+    // We get the current state from memory (or hydrate it if missing, though usually called after get)
+    let current = activeProjects.get(projectId);
+    
+    // If it wasn't in memory, try to get it first to avoid overwriting with partial data
+    if (!current) {
+        current = await StateManager.getProject(projectId) || { 
+            commandQueue: [], 
+            workerHistory: [],
+            pmHistory: [],
+            failureCount: 0 
+        };
+    }
+
+    const timestamp = Date.now();
+    
+    // Merge Data
+    const newData = { 
+        ...current, 
+        ...data, 
+        lastUpdated: timestamp, // UCT timestamp for sync
+        lastActive: timestamp 
     };
-    const newData = { ...current, ...data, lastActive: Date.now() };
+
+    // 1. Write to Memory
     activeProjects.set(projectId, newData);
+
+    // 2. Write to Firebase (Fire and Forget)
+    if (db) {
+        db.ref(`projects/${projectId}`).update(data).catch(err => {
+            console.error(`[StateManager] 🔴 DB Write Failed for ${projectId}:`, err);
+        });
+    }
+
     return newData;
   },
 
-  // PARSE AI RESPONSE FOR COMMANDS
+  /**
+   * QUEUE COMMAND
+   * Parses input, updates command list in Memory & DB
+   */
   queueCommand: async (projectId, input) => {
-    const project = activeProjects.get(projectId);
+    // Ensure project is loaded
+    const project = await StateManager.getProject(projectId);
     if (!project) return;
     
     let command = null;
 
-    // A. HANDLE PRE-FORMED OBJECTS (e.g. Image Assets)
+    // A. HANDLE PRE-FORMED OBJECTS
     if (typeof input === 'object' && input.type && input.payload) {
         command = input;
     } 
@@ -33,19 +108,15 @@ export const StateManager = {
     else if (typeof input === 'string') {
         const rawResponse = input;
 
-        // 1. Internal Consultation Check (Do NOT queue for Plugin)
         if (rawResponse.includes("[ASK_PM:")) {
             console.log(`[${projectId}] Skipped Plugin Queue (Internal PM Consultation)`);
             return; 
         }
 
-        // 2. Image Generation Check (Handled by Server Controller, not Plugin directly usually)
         if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) {
-             // If it's ONLY an image request and no code, we return early as server handles it.
              return;
         }
 
-        // 3. Regex Parsers
         const codeMatch = rawResponse.match(/```(?:lua|luau)?([\s\S]*?)```/i);
         const readScriptMatch = rawResponse.match(/\[READ_SCRIPT:\s*(.*?)\]/);
         const readHierarchyMatch = rawResponse.match(/\[READ_HIERARCHY:\s*(.*?)\]/);
@@ -65,18 +136,48 @@ export const StateManager = {
     if (command) {
       project.commandQueue.push(command);
       console.log(`[${projectId}] Queued Action: ${command.type}`);
+      
+      // Persist the updated queue to both
+      await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
     } else {
         if (typeof input === 'string' && input.length < 500) {
              console.log(`[${projectId}] Chatter (No Command):`, input);
         }
     }
-    
-    activeProjects.set(projectId, project);
   },
   
+  /**
+   * POP COMMAND
+   * Removes from Memory & DB
+   */
   popCommand: async (projectId) => {
-    const project = activeProjects.get(projectId);
+    const project = await StateManager.getProject(projectId);
     if (!project || !project.commandQueue.length) return null;
-    return project.commandQueue.shift();
+    
+    const command = project.commandQueue.shift();
+    
+    // Sync the removal to DB
+    await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
+    
+    return command;
+  },
+
+  /**
+   * CLEANUP
+   * Removes projects from Memory if inactive for > 4 hours
+   */
+  cleanupMemory: () => {
+    const now = Date.now();
+    const FOUR_HOURS = 4 * 60 * 60 * 1000;
+    let count = 0;
+
+    for (const [id, data] of activeProjects.entries()) {
+        if (now - (data.lastActive || 0) > FOUR_HOURS) {
+            activeProjects.delete(id);
+            count++;
+        }
+    }
+    console.log(`[StateManager] 🧹 Memory Cleanup: Removed ${count} inactive projects.`);
+    return count;
   }
 };