Update app.js

app.js

@@ -17,13 +17,13 @@ const app = express();
 const PORT = process.env.PORT || 7860;
 
 app.use(cors());
-app.use(express.json({ limit: '50mb' })); // Using express.json per modern standards
+app.use(express.json({ limit: '50mb' })); 
 
 // --- BILLING CONSTANTS ---
-const MIN_BASIC_REQUIRED = 50; 
-const MIN_DIAMOND_REQUIRED = 50; 
+const MIN_BASIC_REQUIRED = 100; 
+const MIN_DIAMOND_REQUIRED = 100; 
 
-// --- STATUS PHASES (Restored) ---
+// --- STATUS PHASES ---
 const WORKER_PHASES = [
     "Worker: Sorting...",
     "Worker: Analyzing Request...",
@@ -53,14 +53,13 @@ function startStatusLoop(projectId, type = 'worker') {
     StateManager.setStatus(projectId, phases[0]);
 
     const interval = setInterval(() => {
-        index = (index + 1) % phases.length; // Loop properly
+        index = (index + 1) % phases.length; 
         StateManager.setStatus(projectId, phases[index]);
-    }, 3500); 
+    }, 2000); // Slightly faster updates for better UI feedback
 
     return () => clearInterval(interval);
 }
 
-// Restored robust regex helpers
 function extractWorkerPrompt(text) {
     if (!text || typeof text !== 'string') return null;
     const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
@@ -102,26 +101,36 @@ const validateRequest = (req, res, next) => {
     next();
 };
 
-// --- BILLING LOGIC (Inherited from active version) ---
+// --- BILLING LOGIC ---
 
 async function checkMinimumCredits(userId, type = 'basic') {
+    if (!supabase) return;
     const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
-    if (!data) return; // Fail silently or throw, strictly checking existing user
+    if (!data) return; 
+    
     const credits = data.credits?.[type] || 0;
     const req = type === 'diamond' ? MIN_DIAMOND_REQUIRED : MIN_BASIC_REQUIRED;
-    if (credits < req) throw new Error(`Insufficient ${type} credits. Required: ${req}, Available: ${credits}`);
+    
+    if (credits < req) {
+        throw new Error(`Insufficient ${type} credits. Required: ${req}, Available: ${credits}`);
+    }
 }
 
 async function deductUserCredits(userId, amount, type = 'basic') {
     const deduction = Math.floor(parseInt(amount, 10));
-    if (!deduction || deduction <= 0) return;
+    if (!supabase || !deduction || deduction <= 0) return;
 
     try {
         const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
         if (!data) return;
+        
         const currentCredits = data.credits || { basic: 0, diamond: 0 };
-        const newVal = Math.max(0, (currentCredits[type] || 0) - deduction);
-        await supabase.from('users').update({ credits: { ...currentCredits, [type]: newVal } }).eq('id', userId);
+        const currentVal = currentCredits[type] || 0;
+        const newVal = Math.max(0, currentVal - deduction);
+        
+        const updatedCredits = { ...currentCredits, [type]: newVal };
+        
+        await supabase.from('users').update({ credits: updatedCredits }).eq('id', userId);
         console.log(`[Credits] User ${userId} | -${deduction} ${type} | Remaining: ${newVal}`);
     } catch (err) { 
         console.error("Deduction failed", err); 
@@ -192,7 +201,6 @@ async function runBackgroundInitialization(projectId, userId, description) {
         
         let workerTextAccumulated = "";
 
-        // We use stream here to populate UI immediately if user is watching
         const workerResult = await AIEngine.callWorkerStream(
             [], 
             initialWorkerPrompt, 
@@ -208,6 +216,7 @@ async function runBackgroundInitialization(projectId, userId, description) {
                 StateManager.appendStream(projectId, chunk);
             }
         );
+        stopStatus();
         
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
 
@@ -230,7 +239,6 @@ async function runBackgroundInitialization(projectId, userId, description) {
         await StateManager.updateProject(projectId, { status: "error" });
     } finally {
         StateManager.unlock(projectId);
-        // Deduct collected usage
         if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
         if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
     }
@@ -245,7 +253,8 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
     try {
         console.log(`[${projectId}] Feedback received. Persisting state immediately.`);
         
-        // 1. Instant Persistence
+        // 1. Instant Persistence: Saves status and message BEFORE processing
+        // This ensures if user reloads, the state is preserved
         await Promise.all([
             StateManager.updateProject(projectId, { status: "working" }),
             StateManager.addHistory(projectId, 'worker', 'user', fullInput)
@@ -259,6 +268,8 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
         let firstTurnResponse = ""; 
         let thoughtText = "";
         
+        // Clone history to prevent mutation issues
+        // Note: project.workerHistory includes the message we just saved above
         const currentWorkerHistory = [...(project.workerHistory || [])];
 
         // 2. First Turn (Worker Execution)
@@ -281,16 +292,17 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
         );
         stopStatus();
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
+        firstTurnResponse = workerResult.text || firstTurnResponse;
 
         // 3. Analyze Output (Delegation/Questions)
-        const routeTask = extractRouteToPM(workerResult.text);
-        const pmQuestion = extractPMQuestion(workerResult.text);
-        let finalResponseToSave = workerResult.text;
+        const routeTask = extractRouteToPM(firstTurnResponse);
+        const pmQuestion = extractPMQuestion(firstTurnResponse);
+        let finalResponseToSave = firstTurnResponse;
 
         if (routeTask || pmQuestion) {
-            // Save preliminary response
-            await StateManager.addHistory(projectId, 'worker', 'model', workerResult.text);
-            currentWorkerHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
+            // Save preliminary response to DB so it doesn't get lost
+            await StateManager.addHistory(projectId, 'worker', 'model', firstTurnResponse);
+            currentWorkerHistory.push({ role: 'model', parts: [{ text: firstTurnResponse }] });
 
             let pmPrompt = "";
             let pmContextPrefix = "";
@@ -328,17 +340,20 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
             );
             stopStatus();
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
+            pmResponseText = pmResult.text || pmResponseText;
             
             await StateManager.addHistory(projectId, 'pm', 'user', pmPrompt);
             await StateManager.addHistory(projectId, 'pm', 'model', pmResponseText);
 
-            // Execute PM Code if found
+            // --- EXECUTE PM CODE ---
+            // If the PM wrote code (e.g. ServerScriptService logic), execute it immediately
             await processAndQueueResponse(projectId, pmResponseText, userId);
 
             // 5. Run Worker Continuation
             const nextInstruction = extractWorkerPrompt(pmResponseText) || pmResponseText;
             const workerContinuationPrompt = `${pmContextPrefix} ${nextInstruction}\n\nBased on this, continue the task and output the code.`;
 
+            // Add system prompt to history
             await StateManager.addHistory(projectId, 'worker', 'user', workerContinuationPrompt);
             currentWorkerHistory.push({ role: 'user', parts: [{ text: workerContinuationPrompt }] });
 
@@ -363,27 +378,33 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
                 }
             );
             stopStatus();
-            // Only bill completion tokens for continuation to avoid double charging history
-            basicUsage += (secondWorkerResult.usage?.outputTokens || secondWorkerResult.usage?.totalTokenCount || 0);
+            
+            // Deduct usage for second turn
+            basicUsage += (secondWorkerResult.usage?.totalTokenCount || 0);
+            secondTurnResponse = secondWorkerResult.text || secondTurnResponse;
 
             await StateManager.addHistory(projectId, 'worker', 'model', secondTurnResponse);
             finalResponseToSave = secondTurnResponse;
 
         } else {
-            // No delegation, save the single turn
+            // No delegation, just save the first response
             await StateManager.addHistory(projectId, 'worker', 'model', firstTurnResponse);
         }
 
         StateManager.setStatus(projectId, "Idle");
-        await StateManager.updateProject(projectId, { status: "idle" });
-
+        
         // 6. Final Execution & Cleanup
         await processAndQueueResponse(projectId, finalResponseToSave, userId);
+        
+        // Ensure status is idle (this also updates timestamps)
+        await StateManager.updateProject(projectId, { status: "idle" });
 
     } catch (err) {
         console.error("Async Feedback Error:", err);
+        StateManager.setStatus(projectId, "Error: " + err.message);
         await StateManager.updateProject(projectId, { status: "error" });
     } finally {
+        // Billing
         if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
         if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
     }
@@ -392,13 +413,13 @@ async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
 async function processAndQueueResponse(projectId, rawResponse, userId) {
     if (!rawResponse) return;
     
-    // Image Generation Handling
+    // Image Generation
     const imgPrompt = extractImagePrompt(rawResponse);
     if (imgPrompt) {
         try {
             const imgResult = await AIEngine.generateImage(imgPrompt);
             if (imgResult?.image) {
-                if (userId) await deductUserCredits(userId, 1000, 'basic'); // Flat fee for images
+                if (userId) await deductUserCredits(userId, 1000, 'basic'); // Flat fee
                 await StateManager.queueCommand(projectId, { type: "CREATE_ASSET", payload: imgResult.image });
             }
         } catch (e) {
@@ -407,12 +428,16 @@ async function processAndQueueResponse(projectId, rawResponse, userId) {
     }
     
     // Code Execution
-    const codeMatch = rawResponse.match(/```(?:lua)?([\s\S]*?)```/);
+    // Regex looks for lua/luau code blocks to execute
+    const codeMatch = rawResponse.match(/```(?:lua|luau)?([\s\S]*?)```/i);
+    
     if (codeMatch) {
         await StateManager.queueCommand(projectId, { type: "EXECUTE", payload: codeMatch[1].trim() });
     } else {
-        // Fallback: If the response is purely code but without blocks (rare but possible)
-        await StateManager.queueCommand(projectId, { type: "EXECUTE", payload: rawResponse });
+        // If there's no code block but response is non-empty, maybe check if it's pure code?
+        // For safety, we usually only execute if wrapped in blocks. 
+        // But if you want to support raw text execution:
+        // await StateManager.queueCommand(projectId, { type: "EXECUTE", payload: rawResponse });
     }
 }
 
@@ -423,8 +448,14 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
     if (!description) return res.status(400).json({ error: "Description required" });
 
     try {
-        await checkMinimumCredits(userId, 'basic');
-        const result = await AIEngine.generateEntryQuestions(description);
+       // await checkMinimumCredits(userId, 'basic');
+       try {
+            await checkMinimumCredits(userId, 'basic');
+        } catch (creditErr) {
+            return res.json({ success: false, insufficient: true, error: creditErr.message });
+        }
+      
+      const result = await AIEngine.generateEntryQuestions(description);
      
         if (result.usage?.totalTokenCount > 0) {
             await deductUserCredits(userId, result.usage.totalTokenCount, 'basic');
@@ -444,15 +475,19 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
     const { userId, description, answers } = req.body;
     
     try {
-        await checkMinimumCredits(userId, 'basic');
-        await checkMinimumCredits(userId, 'diamond'); 
+        
+      try {
+            await checkMinimumCredits(userId, 'basic');
+            await checkMinimumCredits(userId, 'diamond'); 
+      } catch (creditErr) {
+            return res.json({ success: false, insufficient: true, error: creditErr.message });
+        }
 
         const randomHex = (n = 6) => crypto.randomBytes(Math.ceil(n/2)).toString("hex").slice(0, n);
         const projectId = `proj_${Date.now()}_${randomHex(7)}`;
 
         const gradingResult = await AIEngine.gradeProject(description, answers);
         
-        // Deduct grading cost immediately
         if (gradingResult.usage?.totalTokenCount) {
              await deductUserCredits(userId, gradingResult.usage.totalTokenCount, 'basic');
         }
@@ -477,7 +512,6 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                 return res.status(500).json({ error: "Database save failed" });
             }
 
-            // Kick off background initialization
             runBackgroundInitialization(projectId, userId, description);
         }
 
@@ -502,12 +536,18 @@ app.post('/project/feedback', async (req, res) => {
         const project = await StateManager.getProject(projectId);
         if (!project || project.userId !== userId) return res.status(403).json({ error: "Auth Error" });
 
-        await checkMinimumCredits(userId, 'basic');
+        // --- FIXED CREDIT CHECK ---
+        // Catch credit errors here to return a soft 200 OK so frontend banner shows
+        try {
+            await checkMinimumCredits(userId, 'basic');
+        } catch (creditErr) {
+            return res.json({ success: false, insufficient: true, error: creditErr.message });
+        }
         
         const context = formatContext({ hierarchyContext, scriptContext, logContext });
         const fullInput = `USER: ${prompt || "Automatic Feedback"}${context}`;
         
-        // Trigger Async - Process continues in background
+        // Trigger Async
         runAsyncFeedback(projectId, userId, fullInput, images || []);
 
         res.json({ success: true, message: "Processing started" });
@@ -527,14 +567,12 @@ app.post('/project/ping', async (req, res) => {
     if (!project || project.userId !== userId) return res.json({ action: "IDLE" });
 
     if (isFrontend) {
-        // Return Snapshot for streaming UI
         return res.json({ 
             status: StateManager.getStatus(projectId), 
             snapshot: StateManager.getSnapshot(projectId) 
         });
     }
 
-    // Backend Polling for Commands
     const command = await StateManager.popCommand(projectId);
     const streamData = StateManager.popStream(projectId);
 
@@ -559,14 +597,13 @@ app.post('/human/override', validateRequest, async (req, res) => {
         await checkMinimumCredits(userId, 'basic');
         const project = await StateManager.getProject(projectId);
         
-        res.json({ success: true }); // Respond immediately
+        res.json({ success: true }); 
 
         const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
         
         let overrideText = "";
         let stopStatus = startStatusLoop(projectId, 'worker');
 
-        // Async execution of override
         const workerResult = await AIEngine.callWorkerStream(
             project.workerHistory, 
             overrideMsg,
@@ -582,7 +619,6 @@ app.post('/human/override', validateRequest, async (req, res) => {
                 StateManager.appendStream(projectId, chunk);
             }
         );
-
         stopStatus();
         
         await StateManager.addHistory(projectId, 'worker', 'user', overrideMsg);
@@ -593,7 +629,6 @@ app.post('/human/override', validateRequest, async (req, res) => {
         if (usage > 0) await deductUserCredits(userId, usage, 'basic');
 
     } catch (err) {
-        // Since we already responded with json success, we just log here
         console.error("Override failed", err);
     }
 });