thrust-cli 1.0.10 → 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.10",
+  "version": "1.0.12",
   "description": "The local agent for Thrust AI Director",
   "type": "module",
   "homepage": "https://thrust.web.app",
@@ -19,7 +19,6 @@
   ],
   "author": "Thrust",
   "dependencies": {
-    "auto-launch": "^5.0.6",
     "axios": "^1.13.2",
     "chokidar": "^3.6.0",
     "commander": "^12.0.0",
@@ -27,7 +26,6 @@
     "express": "5.2.1",
     "inquirer": "^9.3.8",
     "inquirer-file-tree-selection-prompt": "^2.0.5",
-    "jsonwebtoken": "^9.0.2",
     "open": "11.0.0",
     "semver": "^7.6.0",
     "simple-git": "^3.22.0",

package/utils/config.js

@@ -6,9 +6,13 @@ const CONFIG_DIR = path.join(os.homedir(), '.thrust');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 const DEFAULT_CONFIG = {
-    token: null,
+    auth: {
+        token: null,
+        user: null
+    },
     activeLeadId: null,
-    leads: {}
+    leads: {},
+    mcpServers: [] // NEW: Stores external MCP servers we poll (Feed-In Client)
 };
 
 export function initConfig() {
@@ -28,7 +32,13 @@ export function getConfig() {
     initConfig();
     try {
         const data = fs.readFileSync(CONFIG_FILE, 'utf8');
-        return JSON.parse(data);
+        const parsed = JSON.parse(data);
+        
+        // Ensure legacy configs get the new objects injected safely
+        if (!parsed.auth) parsed.auth = { token: null, user: null };
+        if (!parsed.mcpServers) parsed.mcpServers = []; 
+        
+        return parsed;
     } catch (error) {
         console.error('⚠️ [Config Error] Corrupted config file. Returning defaults.', error.message);
         return { ...DEFAULT_CONFIG };