thrust-cli 1.0.11 → 1.0.13

package/mcps/ThrustMCPBridge.cs

@@ -0,0 +1,226 @@
+using UnityEngine;
+using UnityEditor;
+using System.Net;
+using System.Threading;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using UnityEngine.SceneManagement;
+
+[InitializeOnLoad]
+public static class ThrustMCPBridge
+{
+    private static HttpListener listener;
+    private static Thread listenerThread;
+    
+    // Buffers
+    private static List<string> activityBuffer = new List<string>();
+    private static List<string> consoleBuffer = new List<string>();
+    private static readonly object bufferLock = new object();
+    
+    // Main Thread Dispatcher variables
+    private static string pendingAction = null;
+    private static string pendingArgument = null;
+    private static string actionResult = null;
+    private static volatile bool isProcessingOnMainThread = false;
+
+    private const int PORT = 8081; 
+
+    static ThrustMCPBridge()
+    {
+        // 1. Hook into Unity Editor Events
+        EditorApplication.hierarchyChanged += OnHierarchyChanged;
+        EditorApplication.playModeStateChanged += OnPlayModeChanged;
+        UnityEditor.SceneManagement.EditorSceneManager.sceneSaved += OnSceneSaved;
+        Application.logMessageReceived += OnLogMessage;
+        
+        // Hook into the main thread loop to process read requests
+        EditorApplication.update += OnEditorUpdate;
+
+        // 2. Start the local MCP Server
+        StartServer();
+        EditorApplication.quitting += StopServer;
+    }
+
+    private static void AddActivity(string activity)
+    {
+        lock (bufferLock)
+        {
+            activityBuffer.Add($"[{System.DateTime.Now.ToShortTimeString()}] {activity}");
+            if (activityBuffer.Count > 50) activityBuffer.RemoveAt(0); 
+        }
+    }
+
+    private static void OnLogMessage(string logString, string stackTrace, LogType type)
+    {
+        lock (bufferLock)
+        {
+            if (type == LogType.Error || type == LogType.Exception || type == LogType.Warning)
+            {
+                consoleBuffer.Add($"[{type}] {logString}");
+                if (consoleBuffer.Count > 30) consoleBuffer.RemoveAt(0);
+            }
+        }
+    }
+
+    private static void OnHierarchyChanged() => AddActivity("Hierarchy changed.");
+    private static void OnSceneSaved(Scene scene) => AddActivity($"Saved scene: {scene.name}");
+    private static void OnPlayModeChanged(PlayModeStateChange state) => AddActivity($"Play mode state: {state}");
+
+    // --- HTTP SERVER LOOP (Background Thread) ---
+    private static void StartServer()
+    {
+        if (listener != null && listener.IsListening) return;
+        listener = new HttpListener();
+        listener.Prefixes.Add($"http://localhost:{PORT}/");
+        listener.Start();
+
+        listenerThread = new Thread(ListenForRequests) { IsBackground = true };
+        listenerThread.Start();
+        Debug.Log($"[Thrust MCP] Two-Way Unity Bridge active on port {PORT}...");
+    }
+
+    private static void ListenForRequests()
+    {
+        while (listener != null && listener.IsListening)
+        {
+            try { ProcessRequest(listener.GetContext()); }
+            catch (HttpListenerException) { /* Ignored on shutdown */ }
+        }
+    }
+
+    private static void ProcessRequest(HttpListenerContext context)
+    {
+        var request = context.Request;
+        var response = context.Response;
+
+        response.AddHeader("Access-Control-Allow-Origin", "*");
+        response.AddHeader("Access-Control-Allow-Headers", "Content-Type");
+
+        if (request.HttpMethod == "OPTIONS") { SendResponse(response, ""); return; }
+
+        string requestBody;
+        using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
+        {
+            requestBody = reader.ReadToEnd();
+        }
+
+        string resultText = "Unknown command";
+
+        // 1. Parse requested tool name (Crude JSON parsing to avoid dependencies)
+        if (requestBody.Contains("\"name\":\"get_recent_activity\"") || requestBody.Contains("\"name\": \"get_recent_activity\""))
+        {
+            lock (bufferLock)
+            {
+                resultText = activityBuffer.Count == 0 ? "No new activity" : string.Join("\\n", activityBuffer);
+                activityBuffer.Clear();
+            }
+        }
+        else if (requestBody.Contains("\"name\":\"get_console_logs\"") || requestBody.Contains("\"name\": \"get_console_logs\""))
+        {
+            lock (bufferLock)
+            {
+                resultText = consoleBuffer.Count == 0 ? "No recent errors/warnings." : string.Join("\\n", consoleBuffer).Replace("\"", "'");
+                consoleBuffer.Clear();
+            }
+        }
+        else if (requestBody.Contains("\"name\":\"get_hierarchy\"") || requestBody.Contains("\"name\": \"get_hierarchy\""))
+        {
+            resultText = DispatchToMainThread("get_hierarchy", "");
+        }
+        else if (requestBody.Contains("\"name\":\"get_properties\"") || requestBody.Contains("\"name\": \"get_properties\""))
+        {
+            // Extract the target parameter safely (e.g., "target": "Player")
+            string target = ExtractJsonValue(requestBody, "target");
+            resultText = DispatchToMainThread("get_properties", target);
+        }
+
+        // Format as JSON-RPC response
+        string responseJson = $@"{{
+            ""jsonrpc"": ""2.0"",
+            ""result"": {{ ""content"": [{{ ""type"": ""text"", ""text"": ""{resultText}"" }}] }}
+        }}";
+
+        SendResponse(response, responseJson);
+    }
+
+    // --- MAIN THREAD DISPATCHER ---
+    // Passes the request to the main thread and waits for the result
+    private static string DispatchToMainThread(string action, string arg)
+    {
+        pendingAction = action;
+        pendingArgument = arg;
+        actionResult = null;
+        isProcessingOnMainThread = true;
+
+        // Block background thread until main thread finishes
+        while (isProcessingOnMainThread) { Thread.Sleep(10); }
+        
+        return actionResult;
+    }
+
+    // Executes on Unity's Main Thread
+    private static void OnEditorUpdate()
+    {
+        if (!isProcessingOnMainThread) return;
+
+        try
+        {
+            if (pendingAction == "get_hierarchy")
+            {
+                var rootObjects = SceneManager.GetActiveScene().GetRootGameObjects();
+                string hierarchy = "Active Scene Hierarchy:\\n";
+                foreach (var go in rootObjects) hierarchy += $"- {go.name}\\n";
+                actionResult = hierarchy;
+            }
+            else if (pendingAction == "get_properties")
+            {
+                if (string.IsNullOrEmpty(pendingArgument)) {
+                    actionResult = "Error: No target specified.";
+                } else {
+                    GameObject go = GameObject.Find(pendingArgument);
+                    if (go == null) {
+                        actionResult = $"GameObject '{pendingArgument}' not found in active scene.";
+                    } else {
+                        actionResult = $"Properties for '{go.name}':\\nPosition: {go.transform.position}\\nRotation: {go.transform.eulerAngles}\\nComponents:\\n";
+                        foreach (var comp in go.GetComponents<Component>())
+                        {
+                            if(comp != null) actionResult += $"- {comp.GetType().Name}\\n";
+                        }
+                    }
+                }
+            }
+        }
+        catch (System.Exception e) { actionResult = $"Error reading Unity state: {e.Message}"; }
+
+        isProcessingOnMainThread = false; // Release the background thread
+    }
+
+    // Utility
+    private static string ExtractJsonValue(string json, string key)
+    {
+        string search = $"\"{key}\":";
+        int index = json.IndexOf(search);
+        if (index == -1) search = $"\"{key}\" :"; index = json.IndexOf(search);
+        if (index == -1) return "";
+
+        int start = json.IndexOf("\"", index + search.Length) + 1;
+        int end = json.IndexOf("\"", start);
+        return json.Substring(start, end - start);
+    }
+
+    private static void SendResponse(HttpListenerResponse response, string json)
+    {
+        byte[] buffer = Encoding.UTF8.GetBytes(json);
+        response.ContentType = "application/json";
+        response.ContentLength64 = buffer.Length;
+        response.OutputStream.Write(buffer, 0, buffer.Length);
+        response.OutputStream.Close();
+    }
+
+    private static void StopServer()
+    {
+        if (listener != null) { listener.Stop(); listener.Close(); listener = null; }
+        if (listenerThread != null) { listenerThread.Abort(); listenerThread = null; }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thrust-cli",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "The local agent for Thrust AI Director",
   "type": "module",
   "homepage": "https://thrust.web.app",

package/utils/daemon.js

@@ -20,8 +20,8 @@ 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) 
+const INACTIVITY_DELAY_MS = 15 * 1000; // Wait for 15 seconds of silence across ALL inputs before sending
+const MCP_POLL_INTERVAL_MS = 18 * 1000; // Poll external tools every 18 seconds
 
 let currentWatcher = null;
 let inactivityTimer = null;
@@ -59,6 +59,18 @@ function isBinaryData(buffer) {
     return false;
 }
 
+// --- CENTRAL DEBOUNCER ---
+// Called by local file changes AND MCP events. It resets the 15s timer.
+function triggerDebouncedSync() {
+    const activeProject = getActiveProject();
+    if (!activeProject || !activeProject.path) return;
+
+    if (inactivityTimer) clearTimeout(inactivityTimer);
+    inactivityTimer = setTimeout(() => {
+        syncContext(activeProject.path);
+    }, INACTIVITY_DELAY_MS);
+}
+
 export async function startDaemon(preferredPort) {
     const actualPort = await findAvailablePort(preferredPort);
     const app = express();
@@ -67,7 +79,7 @@ export async function startDaemon(preferredPort) {
         const origin = req.header('Origin');
         const allowedWebApps = ['https://thrust.web.app', 'http://localhost:3000'];
         if (req.path.startsWith('/api/mcp')) {
-            callback(null, { origin: true }); 
+            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 });
@@ -102,7 +114,7 @@ export async function startDaemon(preferredPort) {
                 headers: { 'Authorization': `Bearer ${token}` }
             });
             const data = await response.json();
-            
+
             res.json({
                 projectId,
                 projectPath: config.leads[projectId].path,
@@ -114,30 +126,26 @@ export async function startDaemon(preferredPort) {
         }
     });
 
-    app.post('/api/mcp/timeline', async (req, res) => {
+    app.post('/api/mcp/timeline', (req, res) => {
         const { source, action_type, description, requires_code_sync } = req.body;
-        
+
         if (!source || !description) {
             return res.status(400).json({ error: "Malformed MCP payload." });
         }
 
         broadcastLocalLog('mcp', `🔗 [${source} Pushed Event] ${action_type}: ${description}`);
 
+        // Add to buffer and reset the 15-second countdown
         fileActivityBuffer += `\n[${new Date().toLocaleTimeString()}] [MCP EXT EVENT] Source: ${source} | Action: ${action_type} | Desc: ${description} | Needs Code Sync: ${requires_code_sync ? 'Yes' : 'No'}\n`;
+        triggerDebouncedSync();
 
-        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." });
+        res.json({ success: true, message: "Timeline event ingested to buffer." });
     });
 
     // ==========================================
     // MCP CLIENT CONFIGURATION (FEED-IN PULL)
     // ==========================================
-    
+
     app.get('/api/mcp/servers', (req, res) => {
         res.json(getConfig().mcpServers || []);
     });
@@ -145,13 +153,12 @@ export async function startDaemon(preferredPort) {
     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 });
     });
@@ -166,6 +173,53 @@ export async function startDaemon(preferredPort) {
         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();
+
+        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 {
+            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.";
+
+            broadcastLocalLog('mcp', `⚡ Queried ${serverName} for ${toolName}.`);
+
+            // Add the query result to the buffer and reset the 15-second countdown
+            fileActivityBuffer += `\n[${new Date().toLocaleTimeString()}] [MCP DIRECT QUERY RESULT] Source: ${serverName} | Tool: ${toolName} | Target: ${targetArg || 'none'} \nResult:\n${resultText}\n`;
+            triggerDebouncedSync();
+
+            res.json({ success: true, data: resultText });
+
+        } catch (e) {
+            broadcastLocalLog('error', `⚠️ Failed to query MCP server: ${serverName}`);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
     // ==========================================
     // CORE DASHBOARD API
     // ==========================================
@@ -234,6 +288,7 @@ export async function startDaemon(preferredPort) {
             if (!response.ok) throw new Error(data.error);
 
             if (config.leads[projectId]?.path) {
+                // Instantly sync when a task is manually completed to update cloud state fast
                 if (inactivityTimer) clearTimeout(inactivityTimer);
                 syncContext(config.leads[projectId].path);
             }
@@ -320,10 +375,10 @@ export async function startDaemon(preferredPort) {
         saveConfig(config);
 
         await startWatching(folderPath);
-        
-        if (inactivityTimer) clearTimeout(inactivityTimer);
-        syncContext(folderPath);
-        
+
+        // Initial sync on link
+        triggerDebouncedSync();
+
         res.json({ success: true });
     });
 
@@ -402,7 +457,6 @@ async function pollExternalMCPServers() {
 
     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' },
@@ -416,11 +470,9 @@ async function pollExternalMCPServers() {
 
             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}`);
@@ -429,16 +481,13 @@ async function pollExternalMCPServers() {
                 }
             }
         } catch (e) {
-            broadcastLocalLog('error', `⚠️ Failed to poll MCP: ${server.name}`);
+            // Silently fail to avoid spamming the logs if Unity is temporarily closed
         }
     }
 
     if (hasNewData) {
-        const activeProject = getActiveProject();
-        if (activeProject && activeProject.path) {
-            if (inactivityTimer) clearTimeout(inactivityTimer);
-            await syncContext(activeProject.path);
-        }
+        // Add to buffer and reset the 15-second countdown
+        triggerDebouncedSync();
     }
 }
 
@@ -465,10 +514,8 @@ async function startWatching(projectPath) {
             fileActivityBuffer += `[${new Date().toLocaleTimeString()}] ${event.toUpperCase()}: ${relativePath}\n`;
             broadcastLocalLog('watch', `[${event.toUpperCase()}] ${relativePath}`);
 
-            if (inactivityTimer) clearTimeout(inactivityTimer);
-            inactivityTimer = setTimeout(() => {
-                syncContext(projectPath);
-            }, INACTIVITY_DELAY_MS);
+            // Reset the 15-second countdown
+            triggerDebouncedSync();
         });
     } catch (err) {}
 }