thrust-cli 1.0.11 → 1.0.12

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.12",
   "description": "The local agent for Thrust AI Director",
   "type": "module",
   "homepage": "https://thrust.web.app",

package/utils/daemon.js

@@ -166,6 +166,56 @@ 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();
+        
+        // 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.";
+            
+            // 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`;
+
+            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
     // ==========================================