Update app.js

app.js

@@ -17,7 +17,6 @@ try {
         const serviceAccount = JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT_JSON);
         
         // We assume the project ID is available in the service account to construct the bucket name
-        // Or you can hardcode your bucket: "your-project-id.firebasestorage.app"
         const bucketName = `shago-web.firebasestorage.app`; 
 
         if (admin.apps.length === 0) {
@@ -119,7 +118,6 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
 app.post('/onboarding/create', validateRequest, async (req, res) => {
     const { userId, description, answers } = req.body;
 
-    // helper: random hex of N chars (N can be 6 or 7)
     const randomHex = (n = 6) => {
       const bytes = Math.ceil(n / 2);
       return crypto.randomBytes(bytes).toString("hex").slice(0, n);
@@ -144,12 +142,10 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             thumbnailBase64 = await AIEngine.generateImage(imagePrompt);
         }
 
-        // --- UPLOAD TO STORAGE & PREPARE URL ---
         let thumbnailUrl = null;
         if (thumbnailBase64 && storage) {
             try {
                 console.log(`[Onboarding] 📤 Uploading Thumbnail to Storage...`);
-                // Remove header if present to get pure buffer
                 const base64Data = thumbnailBase64.replace(/^data:image\/\w+;base64,/, "");
                 const buffer = Buffer.from(base64Data, 'base64');
                 const bucket = storage.bucket();
@@ -159,22 +155,17 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                     metadata: { contentType: 'image/png' }
                 });
 
-                // Make public and get URL
                 await file.makePublic();
-                // Construct the public URL manually or use file.publicUrl()
                 thumbnailUrl = `https://storage.googleapis.com/${bucket.name}/${projectId}/thumbnail.png`;
                 console.log(`[Onboarding] 🖼️ Thumbnail URL: ${thumbnailUrl}`);
             } catch (uploadErr) {
                 console.error("Storage Upload Failed:", uploadErr);
-                // Fallback: thumbnailUrl remains null, logic continues without crashing
             }
         }
 
         const timestamp = Date.now();
         const status = isFailure ? "rejected" : "Idle";
 
-        // 1. Prepare Memory Object 
-        // Note: storing URL instead of raw Base64 now
         const memoryObject = {
             id: projectId,
             userId,
@@ -191,7 +182,6 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             failureCount: 0
         };
 
-        // 2. FIRESTORE WRITE (Project Indexing)
         if (firestore && !isFailure) {
             try {
                 await firestore.collection('projects').doc(projectId).set({
@@ -206,11 +196,8 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             }
         }
 
-        // 3. REALTIME DB WRITE (Deep State)
         if (db  && !isFailure) {
             const updates = {};
-            
-            // Bucket 1: Info (Lightweight)
             updates[`projects/${projectId}/info`] = {
                 id: projectId,
                 userId,
@@ -222,12 +209,10 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                 status
             };
 
-            // Bucket 2: Thumbnail (Store URL object, not Blob)
             if (thumbnailUrl) {
                 updates[`projects/${projectId}/thumbnail`] = { url: thumbnailUrl };
             }
 
-            // Bucket 3: State (History)
             updates[`projects/${projectId}/state`] = {
                 workerHistory: [],
                 pmHistory: [],
@@ -238,7 +223,6 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             await db.ref().update(updates);
         }
         
-        // 4. Update Memory
         if (!isFailure) {
             await StateManager.updateProject(projectId, memoryObject);
         }
@@ -248,7 +232,7 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             projectId, 
             stats: grading, 
             title: grading.title || "Untitled Project",
-            thumbnail: thumbnailBase64 // thumbnailUrl // Return URL to frontend
+            thumbnail: thumbnailBase64
         });
 
     } catch (err) {
@@ -259,26 +243,28 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
 
 // --- CORE ENDPOINTS ---
 
-app.post('/new/project', validateRequest, async (req, res) => {
-    const { userId, projectId, description } = req.body;
+// NEW: Helper function to run initialization in background
+async function runBackgroundInitialization(projectId, userId, description) {
+    console.log(`[Background] Starting initialization for ${projectId}`);
     try {
         const pmHistory = [];
-        await db.ref(`projects/${projectId}/info/status`).set("working");
-      
+        
+        // 1. Generate GDD
         const gddPrompt = `Create a comprehensive GDD for: ${description}`;
         const gddResponse = await AIEngine.callPM(pmHistory, gddPrompt);
         
         pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
         pmHistory.push({ role: 'model', parts: [{ text: gddResponse }] });
 
+        // 2. Generate First Task
         const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
         const taskResponse = await AIEngine.callPM(pmHistory, taskPrompt);
 
         pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
         pmHistory.push({ role: 'model', parts: [{ text: taskResponse }] });
 
+        // 3. Initialize Worker
         const initialWorkerInstruction = extractWorkerPrompt(taskResponse) || `Initialize structure for: ${description}`;
-
         const workerHistory = [];
         const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
         const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt, []);
@@ -286,6 +272,7 @@ app.post('/new/project', validateRequest, async (req, res) => {
         workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
         workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
+        // 4. Update Memory & DB
         await StateManager.updateProject(projectId, {
             userId,
             pmHistory,
@@ -295,28 +282,48 @@ app.post('/new/project', validateRequest, async (req, res) => {
         });
 
         await processAndQueueResponse(projectId, workerResponse);
-        await db.ref(`projects/${projectId}/info/status`).set("working");
-      
-      res.json({ success: true, message: "Workspace Initialized", gddPreview: gddResponse.substring(0, 200) });
+        
+        // 5. Update Status to IDLE (Ready for user input)
+        if(db) await db.ref(`projects/${projectId}/info/status`).set("IDLE");
+        
+        console.log(`[Background] Initialization complete for ${projectId}`);
+
     } catch (err) {
-        console.error("Init Error:", err);
-        res.status(500).json({ error: "Initialization Failed" });
+        console.error(`[Background] Init Error for ${projectId}:`, err);
+        if(db) await db.ref(`projects/${projectId}/info/status`).set("error");
     }
+}
+
+app.post('/new/project', validateRequest, (req, res) => {
+    const { userId, projectId, description } = req.body;
+    
+    // 1. Immediately acknowledge request
+    // We set status to 'working' or 'initializing' immediately so frontend shows a loader
+    if(db) db.ref(`projects/${projectId}/info/status`).set("initializing");
+
+    res.json({ 
+        success: true, 
+        message: "Project initialization started in background."
+    });
+
+    // 2. Trigger background process (no await)
+    runBackgroundInitialization(projectId, userId, description);
 });
 
 app.post('/project/feedback', async (req, res) => {
     const { userId, projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete, images } = req.body;
     
-    // This now handles Hydration automatically
     const project = await StateManager.getProject(projectId);
     
     if (!project) return res.status(404).json({ error: "Project not found." });
    
-  if (project.userId !== userId) {
+    if (project.userId !== userId) {
         console.warn(`[Security] Unauthorized ping for ${projectId}. Owner: ${project.userId}, Request: ${userId}`);
         return res.status(403).json({ error: "Unauthorized: You do not own this project." });
-   }
-   await db.ref(`projects/${projectId}/info/status`).set("working");
+    }
+    
+    // Update status to working immediately
+    if(db) await db.ref(`projects/${projectId}/info/status`).set("working");
       
     if (taskComplete) {
         console.log(`[${projectId}] ✅ TASK COMPLETE.`);
@@ -329,6 +336,7 @@ app.post('/project/feedback', async (req, res) => {
         const nextInstruction = extractWorkerPrompt(pmResponse);
         if (!nextInstruction) {
              await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, status: "IDLE" });
+             if(db) await db.ref(`projects/${projectId}/info/status`).set("IDLE");
              return res.json({ success: true, message: "No further tasks. Project Idle." });
         }
 
@@ -347,6 +355,7 @@ app.post('/project/feedback', async (req, res) => {
 
         StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "warn('Starting Next Task...')" });
         await processAndQueueResponse(projectId, workerResponse);
+        if(db) await db.ref(`projects/${projectId}/info/status`).set("working"); // Keep working while plugin picks it up? Or IDLE to wait for plugin?
         return res.json({ success: true, message: "Next Task Assigned" });
     }
 
@@ -420,9 +429,13 @@ app.post('/project/feedback', async (req, res) => {
         });
         
         await processAndQueueResponse(projectId, response);
-       await db.ref(`projects/${projectId}/info/status`).set("working");
+        // Ensure status goes back to working or IDLE depending on your loop preference.
+        // Usually, if we just gave a command, we are 'working' until the plugin polls and finishes.
+        // But for UI feedback, 'working' usually means "AI is generating". 
+        // Once generated (here), we might want to set it to 'IDLE' or 'waiting_for_plugin'.
+        if(db) await db.ref(`projects/${projectId}/info/status`).set("working");
       
-      res.json({ success: true });
+        res.json({ success: true });
     } catch (err) {
         console.error("AI Error:", err);
         res.status(500).json({ error: "AI Failed" });
@@ -430,31 +443,23 @@ app.post('/project/feedback', async (req, res) => {
 });
 
 app.post('/project/ping', async (req, res) => {
-    // 1. Accept userId along with projectId
     const { projectId, userId } = req.body;
- // console.log("1");
 
     if (!projectId || !userId) {
         return res.status(400).json({ error: "Missing ID fields" });
     }
-  // console.log("2");
-    // 2. Retrieve Project State (Hydrates from DB if not in memory)
+    
     const project = await StateManager.getProject(projectId);
     
     if (!project) {
-        // If project doesn't exist in Memory or DB
-      console.log("project not found in db, id: ", projectId);
         return res.status(404).json({ action: "IDLE", error: "Project not found" });
     }
-  // console.log("3");
 
-    // 3. SECURITY CHECK: Ensure the user matches the project owner
     if (project.userId !== userId) {
         console.warn(`[Security] Unauthorized ping for ${projectId}. Owner: ${project.userId}, Request: ${userId}`);
         return res.status(403).json({ error: "Unauthorized: You do not own this project." });
     }
-// console.log("4");
-    // 4. Retrieve Command (Only if authorized)
+
     const command = await StateManager.popCommand(projectId);
     
     if (command) {
@@ -467,29 +472,10 @@ app.post('/project/ping', async (req, res) => {
                 code: command.type === 'EXECUTE' ? command.payload : null 
             });
         }
-    } else {
-      // console.log("5");
-        res.json({ action: "IDLE" });
-    }
-});
-
-/*
-app.post('/project/ping', async (req, res) => {
-    const { projectId } = req.body;
-    // This will hydrate from DB if missing
-    const command = await StateManager.popCommand(projectId);
-    
-    if (command) {
-        if (command.payload === "CLEAR_CONSOLE") {
-             res.json({ action: "CLEAR_LOGS" });
-        } else {
-            res.json({ action: command.type, target: command.payload, code: command.type === 'EXECUTE' ? command.payload : null });
-        }
     } else {
         res.json({ action: "IDLE" });
     }
 });
-*/
 
 app.post('/human/override', validateRequest, async (req, res) => {
     const { projectId, instruction, pruneHistory } = req.body;