thrust-cli 1.0.10 → 1.0.12

package/utils/daemon.js

@@ -1,4 +1,4 @@
-import { WebSocket, WebSocketServer } from 'ws'; 
+import { WebSocket, WebSocketServer } from 'ws';
 import chokidar from 'chokidar';
 import simpleGit from 'simple-git';
 import express from 'express';
@@ -15,14 +15,21 @@ import { getActiveProject, getConfig, saveConfig } from './config.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const GATEWAY_URL = process.env.FRONT_URL || "ws://localhost:7860";
+const GATEWAY_URL = process.env.FRONT_URL || "wss://everydaycats-thrust-front-server.hf.space";
+const API_URL = GATEWAY_URL.replace('ws://', 'http://').replace('wss://', 'https://');
+const AUTH_PROXY_URL = "https://everydaycats-thrust-auth-server.hf.space";
+
+// --- DEBOUNCE & POLLING TIMERS ---
+const INACTIVITY_DELAY_MS = 15 * 1000; // 30 * 1000; // lets make it 15 seconds instead 
+const MCP_POLL_INTERVAL_MS = 18 * 1000; // 0.3 * 60 * 1000; // Poll external tools every 0.3 mins (18 seconds) 
 
 let currentWatcher = null;
-let syncTimeout = null;
-let globalWs = null;        
-let localWss = null;        
-let wsRetryLogged = false; 
-let eaccesWarningLogged = false; 
+let inactivityTimer = null;
+let mcpPollTimer = null;
+let fileActivityBuffer = "";
+let globalWs = null;
+let localWss = null;
+let wsRetryLogged = false;
 
 const findAvailablePort = (startPort) => {
     return new Promise((resolve) => {
@@ -45,53 +52,317 @@ function broadcastLocalLog(type, message) {
     });
 }
 
+function isBinaryData(buffer) {
+    for (let i = 0; i < Math.min(buffer.length, 512); i++) {
+        if (buffer[i] === 0) return true;
+    }
+    return false;
+}
+
 export async function startDaemon(preferredPort) {
     const actualPort = await findAvailablePort(preferredPort);
     const app = express();
 
-    const corsOptions = {
-        origin: `http://localhost:${actualPort}`,
-        optionsSuccessStatus: 200
+    const corsOptionsDelegate = (req, callback) => {
+        const origin = req.header('Origin');
+        const allowedWebApps = ['https://thrust.web.app', 'http://localhost:3000'];
+        if (req.path.startsWith('/api/mcp')) {
+            callback(null, { origin: true }); 
+        } else if (req.path === '/api/auth/callback') {
+            if (!origin || allowedWebApps.includes(origin) || origin === `http://localhost:${actualPort}`) {
+                callback(null, { origin: true, credentials: true });
+            } else {
+                callback(new Error('CORS blocked auth callback'), { origin: false });
+            }
+        } else {
+            callback(null, { origin: `http://localhost:${actualPort}` });
+        }
     };
-    app.use('/api', cors(corsOptions), express.json());
+
+    app.use(cors(corsOptionsDelegate));
+    app.use(express.json());
 
     const frontendPath = path.join(__dirname, '..', 'frontend');
 
-    app.get('/api/status', (req, res) => res.json({ activeProject: getActiveProject() }));
+    // ==========================================
+    // MCP SERVER ENDPOINTS (FEED-IN PUSH)
+    // ==========================================
+
+    app.get('/api/mcp/context', async (req, res) => {
+        const config = getConfig();
+        const token = config.auth?.token;
+        const projectId = config.activeLeadId;
+
+        if (!token || !projectId) {
+            return res.status(401).json({ error: "Thrust agent not linked or authenticated." });
+        }
 
-    app.get('/api/explore', (req, res) => {
         try {
-            let targetPath = req.query.path || os.homedir();
-            targetPath = path.resolve(targetPath);
+            const response = await fetch(`${API_URL}/api/projects/${projectId}/thrusts/active`, {
+                headers: { 'Authorization': `Bearer ${token}` }
+            });
+            const data = await response.json();
+            
+            res.json({
+                projectId,
+                projectPath: config.leads[projectId].path,
+                activeThrust: data.length > 0 ? data[0] : null
+            });
+            broadcastLocalLog('mcp', `🔗 [Context Sync] External client requested project state.`);
+        } catch (e) {
+            res.status(502).json({ error: "Failed to fetch context." });
+        }
+    });
 
-            if (!fs.existsSync(targetPath)) {
-                return res.status(404).json({ error: "Directory not found" });
-            }
+    app.post('/api/mcp/timeline', async (req, res) => {
+        const { source, action_type, description, requires_code_sync } = req.body;
+        
+        if (!source || !description) {
+            return res.status(400).json({ error: "Malformed MCP payload." });
+        }
 
-            const items = fs.readdirSync(targetPath, { withFileTypes: true });
+        broadcastLocalLog('mcp', `🔗 [${source} Pushed Event] ${action_type}: ${description}`);
+
+        fileActivityBuffer += `\n[${new Date().toLocaleTimeString()}] [MCP EXT EVENT] Source: ${source} | Action: ${action_type} | Desc: ${description} | Needs Code Sync: ${requires_code_sync ? 'Yes' : 'No'}\n`;
+
+        const activeProject = getActiveProject();
+        if (activeProject && activeProject.path) {
+            if (inactivityTimer) clearTimeout(inactivityTimer);
+            await syncContext(activeProject.path);
+        }
+
+        res.json({ success: true, message: "Timeline event ingested and sync triggered." });
+    });
+
+    // ==========================================
+    // MCP CLIENT CONFIGURATION (FEED-IN PULL)
+    // ==========================================
+    
+    app.get('/api/mcp/servers', (req, res) => {
+        res.json(getConfig().mcpServers || []);
+    });
+
+    app.post('/api/mcp/servers', (req, res) => {
+        const { name, url } = req.body;
+        if (!name || !url) return res.status(400).json({ error: "Missing name or url" });
+        
+        const config = getConfig();
+        if (!config.mcpServers) config.mcpServers = [];
+        config.mcpServers.push({ name, url, type: 'http' });
+        saveConfig(config);
+        
+        // Trigger an immediate poll when a new service is added
+        pollExternalMCPServers();
+        res.json({ success: true });
+    });
+
+    app.delete('/api/mcp/servers/:index', (req, res) => {
+        const config = getConfig();
+        const index = parseInt(req.params.index);
+        if (config.mcpServers && config.mcpServers[index]) {
+            config.mcpServers.splice(index, 1);
+            saveConfig(config);
+        }
+        res.json({ success: true });
+    });
+
+    // ==========================================
+    // EXTERNAL MCP DIRECT QUERY (AI OR MANUAL)
+    // ==========================================
+    app.post('/api/mcp/query', async (req, res) => {
+
+  const { serverName, toolName, targetArg } = req.body;
+  const config = getConfig();
+        
+        // Find the requested server by name (e.g., "Unity")
+        const server = config.mcpServers?.find(s => s.name.toLowerCase() === serverName.toLowerCase());
+        
+        if (!server) return res.status(404).json({ error: `MCP Server '${serverName}' not found.` });
+
+        try {
+            // Build the JSON-RPC Payload
+            const payload = {
+                jsonrpc: "2.0",
+                method: "tools/call",
+                params: { 
+                    name: toolName, 
+                    arguments: targetArg ? { target: targetArg } : {} 
+                },
+                id: Date.now()
+            };
+
+            const response = await fetch(server.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) throw new Error("Server responded with error");
+            
+            const data = await response.json();
+            const resultText = data.result?.content?.[0]?.text || "No data returned.";
             
-            const directories = items
-                .filter(item => item.isDirectory() && !item.name.startsWith('.'))
-                .map(item => item.name)
-                .sort();
+            // Log it locally so the user sees the system thinking
+            broadcastLocalLog('mcp', `⚡ Queried ${serverName} for ${toolName}.`);
+            
+            // Inject this data directly into the activity buffer so the AI sees it on the next sync
+            fileActivityBuffer += `\n[${new Date().toLocaleTimeString()}] [MCP DIRECT QUERY RESULT] Source: ${serverName} | Tool: ${toolName} | Target: ${targetArg || 'none'} \nResult:\n${resultText}\n`;
 
-            const parentPath = path.dirname(targetPath);
+            res.json({ success: true, data: resultText });
 
-            res.json({
-                currentPath: targetPath,
-                parentPath: targetPath === parentPath ? null : parentPath,
-                directories: directories
+        } catch (e) {
+            broadcastLocalLog('error', `⚠️ Failed to query MCP server: ${serverName}`);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // ==========================================
+    // CORE DASHBOARD API
+    // ==========================================
+
+    app.get('/api/status', (req, res) => {
+        const config = getConfig();
+        res.json({ auth: config.auth, activeProject: getActiveProject() });
+    });
+
+    app.get('/api/cloud-projects', async (req, res) => {
+        const config = getConfig();
+        const token = config.auth?.token;
+        if (!token) return res.status(401).json({ error: "Not authenticated" });
+
+        const page = req.query.page || 1;
+        try {
+            const response = await fetch(`${API_URL}/api/projects?page=${page}&limit=9`, {
+                headers: { 'Authorization': `Bearer ${token}` }
             });
-        } catch (error) {
-            res.status(403).json({ error: "Permission denied." });
+            const data = await response.json();
+            if (!response.ok) throw new Error(data.error);
+            res.json(data);
+        } catch (e) {
+            res.status(502).json({ error: "Failed to fetch from Gateway." });
         }
     });
 
+    app.get('/api/thrusts/active', async (req, res) => {
+        const config = getConfig();
+        const token = config.auth?.token;
+        const projectId = config.activeLeadId;
+
+        if (!token || !projectId) return res.status(401).json({ error: "Not ready" });
+
+        try {
+            const response = await fetch(`${API_URL}/api/projects/${projectId}/thrusts/active`, {
+                headers: { 'Authorization': `Bearer ${token}` }
+            });
+            const data = await response.json();
+            if (!response.ok) throw new Error(data.error);
+            res.json(data);
+        } catch (e) {
+            res.status(502).json({ error: "Failed to fetch current directive." });
+        }
+    });
+
+    app.post('/api/tasks/complete', async (req, res) => {
+        const { taskId, taskTitle } = req.body;
+        const config = getConfig();
+        const token = config.auth?.token;
+        const projectId = config.activeLeadId;
+
+        if (!token || !projectId) return res.status(401).json({ error: "Not authenticated" });
+
+        try {
+            const response = await fetch(`${API_URL}/api/projects/${projectId}/tasks/${taskId}/complete`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ taskTitle })
+            });
+
+            const data = await response.json();
+            if (!response.ok) throw new Error(data.error);
+
+            if (config.leads[projectId]?.path) {
+                if (inactivityTimer) clearTimeout(inactivityTimer);
+                syncContext(config.leads[projectId].path);
+            }
+
+            res.json(data);
+        } catch (e) {
+            res.status(502).json({ error: "Failed to sync task completion to cloud." });
+        }
+    });
+
+    app.post('/api/auth/callback', async (req, res) => {
+        const { tempKey, token, email } = req.body;
+        try {
+            let finalToken = token;
+            if (tempKey && !token) {
+                const response = await fetch(`${AUTH_PROXY_URL}/redeem`, {
+                    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: tempKey })
+                });
+                const data = await response.json();
+                if (!data.token) return res.status(401).json({ error: "Invalid Key" });
+                finalToken = data.token;
+            }
+
+            if (finalToken) {
+                const config = getConfig();
+                config.auth = { token: finalToken, email: email || "Authenticated User" };
+                saveConfig(config);
+                broadcastLocalLog('success', '✅ Authentication Successful!');
+                connectWebSocket();
+                return res.json({ success: true });
+            } else {
+                return res.status(400).json({ error: "No valid auth data provided" });
+            }
+        } catch (e) {
+            res.status(502).json({ error: "Auth Processing Failed" });
+        }
+    });
+
+    app.post('/api/auth/logout', async (req, res) => {
+        const config = getConfig();
+        const token = config.auth?.token;
+        const projectId = config.activeLeadId;
+
+        if (token && projectId) {
+            fetch(`${API_URL}/nullify`, {
+                method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` }, body: JSON.stringify({ projectId })
+            }).catch(() => {});
+        }
+
+        config.auth = { token: null, email: null };
+        config.activeLeadId = null;
+        saveConfig(config);
+
+        if (globalWs) { globalWs.close(); globalWs = null; }
+        if (currentWatcher) { await currentWatcher.close(); currentWatcher = null; }
+        if (inactivityTimer) { clearTimeout(inactivityTimer); inactivityTimer = null; }
+        if (mcpPollTimer) { clearInterval(mcpPollTimer); mcpPollTimer = null; }
+
+        broadcastLocalLog('error', '🛑 Logged out. Session cleared.');
+        res.json({ success: true });
+    });
+
+    app.get('/api/explore', (req, res) => {
+        try {
+            let targetPath = req.query.path || os.homedir();
+            targetPath = path.resolve(targetPath);
+            if (!fs.existsSync(targetPath)) return res.status(404).json({ error: "Directory not found" });
+
+            const items = fs.readdirSync(targetPath, { withFileTypes: true });
+            const directories = items.filter(item => item.isDirectory() && !item.name.startsWith('.')).map(item => item.name).sort();
+            const parentPath = path.dirname(targetPath);
+
+            res.json({ currentPath: targetPath, parentPath: targetPath === parentPath ? null : parentPath, directories: directories });
+        } catch (error) { res.status(403).json({ error: "Permission denied." }); }
+    });
+
     app.post('/api/link', async (req, res) => {
         const { leadId, folderPath } = req.body;
-        if (!fs.existsSync(folderPath)) {
-            return res.status(400).json({ error: "Folder path not found." });
-        }
+        if (!fs.existsSync(folderPath)) return res.status(400).json({ error: "Folder path not found." });
 
         const config = getConfig();
         config.leads[leadId] = { path: folderPath, linkedAt: new Date().toISOString() };
@@ -99,6 +370,10 @@ export async function startDaemon(preferredPort) {
         saveConfig(config);
 
         await startWatching(folderPath);
+        
+        if (inactivityTimer) clearTimeout(inactivityTimer);
+        syncContext(folderPath);
+        
         res.json({ success: true });
     });
 
@@ -110,9 +385,10 @@ export async function startDaemon(preferredPort) {
         if (currentWatcher) {
             await currentWatcher.close();
             currentWatcher = null;
+            if (inactivityTimer) { clearTimeout(inactivityTimer); inactivityTimer = null; }
+            if (mcpPollTimer) { clearInterval(mcpPollTimer); mcpPollTimer = null; }
             broadcastLocalLog('system', '🛑 Stopped watching.');
         }
-
         res.json({ success: true });
     });
 
@@ -130,123 +406,224 @@ export async function startDaemon(preferredPort) {
     });
 
     localWss = new WebSocketServer({ server });
-    
     localWss.on('connection', (ws) => {
-        ws.send(JSON.stringify({ type: 'system', message: '🟢 Local WebSocket connected.' }));
+        ws.send(JSON.stringify({ type: 'system', message: '🟢 Local UI Connected.' }));
         ws.on('message', (message) => {
             try {
                 const data = JSON.parse(message.toString());
                 if (data.type === 'frontend_prompt') {
-                    console.log(`\n💬 [LOCAL UI]: ${data.payload}`);
-                    broadcastLocalLog('ai', `Daemon received prompt: "${data.payload}"`);
+                    if (globalWs && globalWs.readyState === WebSocket.OPEN) {
+                        globalWs.send(JSON.stringify({ type: 'prompt', content: data.payload, projectId: getActiveProject()?.id }));
+                        broadcastLocalLog('sync', `Prompt sent to Cloud Director...`);
+                    } else {
+                        broadcastLocalLog('error', `⚠️ Cannot send: Cloud Gateway is offline.`);
+                    }
                 }
             } catch (err) {}
         });
     });
 
-    connectWebSocket();
-    const initialProject = getActiveProject();
-    if (initialProject?.path) {
-        startWatching(initialProject.path);
+    const config = getConfig();
+    if (config.auth && config.auth.token) {
+        connectWebSocket();
+        const initialProject = getActiveProject();
+        if (initialProject?.path) {
+            startWatching(initialProject.path);
+        }
+    } else {
+        console.log("\n⚠️ Agent is not authenticated. Awaiting connection from Web Dashboard...");
     }
 }
 
-// --- TRULY UNIVERSAL BROWSER OPENER ---
 async function safeOpenBrowser(url) {
     try {
-        if (process.env.TERMUX_VERSION) {
-            exec(`termux-open-url ${url}`, () => {
-                console.log("👉 Please open the URL manually in your mobile browser.");
+        if (process.env.TERMUX_VERSION) exec(`termux-open-url ${url}`, () => {});
+        else if (!process.env.DISPLAY && process.platform === 'linux') {}
+        else { await open(url); }
+    } catch (e) {}
+}
+
+// --- EXTERNAL MCP POLLING LOGIC ---
+async function pollExternalMCPServers() {
+    const config = getConfig();
+    if (!config.mcpServers || config.mcpServers.length === 0) return;
+
+    let hasNewData = false;
+
+    for (const server of config.mcpServers) {
+        try {
+            // Send standard MCP JSON-RPC payload asking for recent activity
+            const res = await fetch(server.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    method: "tools/call",
+                    params: { name: "get_recent_activity", arguments: {} },
+                    id: Date.now()
+                })
             });
-        } else if (!process.env.DISPLAY && process.platform === 'linux') {
-            console.log("👉 [Headless] Please open the URL manually in a browser.");
-        } else {
-            console.log("🌐 Launching dashboard in your default browser...");
-            // By stripping the Chromium-specific '--app' flags and arguments, 
-            // the OS will perfectly route this to Edge, Safari, Firefox, or Chrome.
-            await open(url);
+
+            if (res.ok) {
+                const data = await res.json();
+                
+                // Parse standard MCP response { result: { content: [{ text: "..." }] } }
+                if (data.result && data.result.content && data.result.content.length > 0) {
+                    const updateText = data.result.content[0].text;
+                    
+                    if (updateText && updateText.trim() !== "" && updateText.trim() !== "No new activity") {
+                        fileActivityBuffer += `\n[${new Date().toLocaleTimeString()}] [MCP POLL] Source: ${server.name} | Update: ${updateText}\n`;
+                        broadcastLocalLog('mcp', `🔗 Pulled new data from ${server.name}`);
+                        hasNewData = true;
+                    }
+                }
+            }
+        } catch (e) {
+            broadcastLocalLog('error', `⚠️ Failed to poll MCP: ${server.name}`);
+        }
+    }
+
+    if (hasNewData) {
+        const activeProject = getActiveProject();
+        if (activeProject && activeProject.path) {
+            if (inactivityTimer) clearTimeout(inactivityTimer);
+            await syncContext(activeProject.path);
         }
-    } catch (e) {
-        console.log("\n👉 Please open the URL above manually.\n");
     }
 }
 
+// --- CORE FILE WATCHING LOGIC ---
 async function startWatching(projectPath) {
     try {
         if (currentWatcher) await currentWatcher.close();
-        
-        console.log(`👁️  Watching: ${projectPath}`);
         broadcastLocalLog('system', `👁️ Started watching: ${projectPath}`);
-        
+
+        fileActivityBuffer = "";
+
+        // Start the active polling loop for external services
+        if (mcpPollTimer) clearInterval(mcpPollTimer);
+        mcpPollTimer = setInterval(pollExternalMCPServers, MCP_POLL_INTERVAL_MS);
+
         currentWatcher = chokidar.watch(projectPath, {
-            ignored: [/(^|[\/\\])\../, '**/node_modules/**'],
+            ignored: [/(^|[\/\\])\../, '**/node_modules/**', '**/dist/**', '**/build/**'],
             persistent: true,
             ignoreInitial: true
         });
 
         currentWatcher.on('all', (event, filePath) => {
             const relativePath = path.relative(projectPath, filePath);
+            fileActivityBuffer += `[${new Date().toLocaleTimeString()}] ${event.toUpperCase()}: ${relativePath}\n`;
             broadcastLocalLog('watch', `[${event.toUpperCase()}] ${relativePath}`);
-            clearTimeout(syncTimeout);
-            syncTimeout = setTimeout(() => syncContext(projectPath), 3000);
+
+            if (inactivityTimer) clearTimeout(inactivityTimer);
+            inactivityTimer = setTimeout(() => {
+                syncContext(projectPath);
+            }, INACTIVITY_DELAY_MS);
         });
-    } catch (err) {
-        console.error(`❌ Failed: ${err.message}`);
-    }
+    } catch (err) {}
 }
 
 function connectWebSocket() {
+    const config = getConfig();
+    if (!config.auth || !config.auth.token) return;
+
     try {
-        globalWs = new WebSocket(`${GATEWAY_URL}?token=YOUR_TOKEN_HERE`);
+        if (globalWs) globalWs.close();
+        globalWs = new WebSocket(`${GATEWAY_URL}?token=${config.auth.token}`);
 
         globalWs.on('error', (err) => {
-            if (err.code === 'ECONNREFUSED') {
-                if (!wsRetryLogged) {
-                    console.log('🔴 Cloud Gateway offline (ECONNREFUSED). Will retry silently...');
-                    wsRetryLogged = true;
-                }
-            } else {
-                console.error(`⚠️ Cloud Gateway Error: ${err.message}`);
+            if (err.code === 'ECONNREFUSED' && !wsRetryLogged) {
+                wsRetryLogged = true;
             }
         });
 
         globalWs.on('open', () => {
-            console.log('🟢 Connected to Cloud Gateway.');
-            wsRetryLogged = false; 
-            const activeProj = getActiveProject();
-            if (activeProj) syncContext(activeProj.path);
+            broadcastLocalLog('success', '🟢 Connected to Cloud Gateway.');
+            wsRetryLogged = false;
         });
-        
+
         globalWs.on('message', (data) => {
             try {
                 const msg = JSON.parse(data.toString());
-                if (msg.type === 'toast') {
-                    console.log(`\n🔔 [DIRECTOR]: ${msg.message}`);
-                    broadcastLocalLog('ai', `🔔 [AI DIRECTOR] ${msg.message}`);
+                if (msg.type === 'toast' || msg.type === 'response') {
+                    broadcastLocalLog('ai', `🔔 [AI]: ${msg.message || msg.text}`);
                 }
+                if (msg.type === 'status') broadcastLocalLog('system', `🤖 AI Status: ${msg.status}...`);
+                if (msg.should_reload || msg.type === 'reload_project') broadcastLocalLog('reload', `fetch_thrusts`);
             } catch (err) {}
         });
-        
+
         globalWs.on('close', () => {
             if (!wsRetryLogged) {
-                console.log('🔴 Disconnected from Cloud Gateway. Retrying silently...');
+                broadcastLocalLog('error', '🔴 Disconnected from Cloud Gateway. Retrying...');
                 wsRetryLogged = true;
             }
-            setTimeout(connectWebSocket, 5000);
+            if (getConfig().auth?.token) setTimeout(connectWebSocket, 5000);
         });
-
-    } catch (err) {
-        setTimeout(connectWebSocket, 5000);
-    }
+    } catch (err) { setTimeout(connectWebSocket, 5000); }
 }
 
 async function syncContext(projectPath) {
     if (!globalWs || globalWs.readyState !== WebSocket.OPEN) return;
+
+    const git = simpleGit(projectPath);
+    const isRepo = await git.checkIsRepo().catch(() => false);
+    if (!isRepo) return;
+
     try {
-        const git = simpleGit(projectPath);
         const status = await git.status();
         const diff = await git.diff();
-        globalWs.send(JSON.stringify({ type: "context_sync", data: { files_changed: status.modified, diffs: diff } }));
-        broadcastLocalLog('sync', `✅ Git context synced to AI.`);
-    } catch (e) {}
+
+        if (!fileActivityBuffer.trim() && !diff) return;
+
+        let newFilesData = "";
+        let imagesData = [];
+
+        const binaryExts =[
+            '.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', '.ico',
+            '.pdf', '.zip', '.tar', '.gz', '.mp4', '.mp3', '.wav',
+            '.exe', '.dll', '.so', '.dylib',
+            '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.bin'
+        ];
+
+        for (const file of status.not_added) {
+            const ext = path.extname(file).toLowerCase();
+            const fullPath = path.join(projectPath, file);
+            if (!fs.existsSync(fullPath)) continue;
+
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory() || stat.size > 5 * 1024 * 1024) continue;
+
+            const fileData = fs.readFileSync(fullPath);
+            const isBinary = binaryExts.includes(ext) || isBinaryData(fileData);
+
+            if (isBinary) {
+                const base64 = fileData.toString('base64');
+                const mime = ['.png','.jpg','.jpeg','.webp','.gif'].includes(ext)
+                    ? `image/${ext.replace('.','')}`
+                    : 'application/octet-stream';
+                imagesData.push(`data:${mime};base64,${base64}`);
+            } else {
+                const content = fileData.toString('utf8');
+                newFilesData += `\n--- NEW FILE: ${file} (Scraped at ${new Date().toLocaleTimeString()}) ---\n${content.substring(0, 10000)}\n`;
+            }
+        }
+
+        globalWs.send(JSON.stringify({
+            type: "context_sync",
+            projectId: getActiveProject().id,
+            data: {
+                buffer: fileActivityBuffer,
+                diffs: diff,
+                new_files: newFilesData,
+                images: imagesData
+            }
+        }));
+
+        broadcastLocalLog('sync', `✅ Context Batch synced to AI.`);
+        fileActivityBuffer = ""; 
+
+    } catch (e) {
+        console.error("Sync error:", e);
+    }
 }