@mflrevan/ucp 0.6.0 → 0.6.1

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.6.0` of the Unity Control Protocol CLI.
+Version `0.6.1` of the Unity Control Protocol CLI.
 
 This package installs the `ucp` command, downloads the matching published binary for your platform during `postinstall`, and ships the matching Unity bridge payload inside the npm package.
 

package/bridge/com.ucp.bridge/Editor/Bridge/BridgeServer.cs

@@ -26,7 +26,7 @@ namespace UCP.Bridge
         private const int DefaultPort = 21342;
         private const int MaxPort = 21352;
         private const int MaxConnections = 4;
-        private const string ProtocolVersion = "0.6.0";
+        private const string ProtocolVersion = "0.6.1";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -36,6 +36,13 @@ namespace UCP.Bridge
         private static string s_token;
         private static bool s_running;
 
+        // Handshake payload, captured once on the main thread at startup. `Application.dataPath`
+        // and friends are main-thread-only, which is the sole reason the handshake used to be
+        // queued behind `EditorApplication.update` -- see the socket-thread fast path in Dispatch.
+        private static string s_unityVersion = string.Empty;
+        private static string s_projectName = string.Empty;
+        private static string s_projectPath = string.Empty;
+
         // Main-thread action queue
         private static readonly ConcurrentQueue<Action> s_mainThreadQueue = new();
 
@@ -71,6 +78,7 @@ namespace UCP.Bridge
 
             try
             {
+                CaptureEditorIdentity();
                 RegisterHandlers();
                 LogsController.SeedHistoryFromConsole();
 
@@ -88,18 +96,31 @@ namespace UCP.Bridge
             }
         }
 
+        /// <summary>
+        /// Read the editor/project identity once, on the main thread, so the handshake handler is
+        /// pure and can run anywhere.
+        /// </summary>
+        private static void CaptureEditorIdentity()
+        {
+            s_unityVersion = Application.unityVersion;
+            s_projectName = Application.productName;
+            s_projectPath = Path.GetDirectoryName(Application.dataPath);
+        }
+
         private static void RegisterHandlers()
         {
             // Handshake
             s_router.Register("handshake", (paramsJson) =>
             {
+                // Touches no Unity API -- see CaptureEditorIdentity. Keep it that way: the
+                // socket-thread fast path in Dispatch depends on it.
                 return new
                 {
                     serverVersion = ProtocolVersion,
                     protocolVersion = ProtocolVersion,
-                    unityVersion = Application.unityVersion,
-                    projectName = Application.productName,
-                    projectPath = Path.GetDirectoryName(Application.dataPath)
+                    unityVersion = s_unityVersion,
+                    projectName = s_projectName,
+                    projectPath = s_projectPath
                 };
             });
 
@@ -393,12 +414,22 @@ namespace UCP.Bridge
                 lock (s_clientLock) { s_logSubscribers.Remove(ws); }
             }
 
-            // Dispatch on main thread
             var capturedId = id;
             var capturedMethod = method;
             var capturedParams = paramsJson;
             var capturedWs = ws;
 
+            // Answer the handshake straight off the socket thread. Everything it returns is
+            // cached, so queueing it only bought a wait for the next `EditorApplication.update`
+            // tick -- roughly 90 ms on an idle editor, paid by *every* CLI command before its
+            // real request could even be dispatched.
+            if (capturedMethod == "handshake")
+            {
+                SendResponse(capturedWs, s_router.Dispatch(capturedMethod, capturedId, capturedParams));
+                return;
+            }
+
+            // Dispatch on main thread
             s_mainThreadQueue.Enqueue(() =>
             {
                 var response = s_router.Dispatch(capturedMethod, capturedId, capturedParams);

package/bridge/com.ucp.bridge/Editor/Controllers/CompilationController.cs

@@ -9,19 +9,86 @@ namespace UCP.Bridge
 {
     public static class CompilationController
     {
+        // SessionState survives domain reloads within one editor session. That is exactly the
+        // window we need: a compile that SUCCEEDS reloads the domain, a compile that FAILS keeps
+        // the old domain (no reload), and in both cases the captured diagnostics must still be
+        // readable by the CLI after the editor settles. CompileDiagnosticsTracker writes here;
+        // HandleDiagnostics reads it back.
+        internal const string DiagStateKey = "ucp.compile.diagnostics.state";
+        internal const string DiagRequestKey = "ucp.compile.diagnostics.requestId";
+        private const int MaxDiagnosticMessages = 200;
+
         public static void Register(CommandRouter router)
         {
             router.Register("compile", HandleCompile);
+            router.Register("compile/diagnostics", HandleDiagnostics);
             router.Register("refresh-assets", HandleRefresh);
             router.Register("script/doctor", HandleScriptDoctor);
         }
 
         private static object HandleCompile(string paramsJson)
         {
+            // Stamp a fresh request id and reset the diagnostics buffer so the CLI can tell THIS
+            // compile's result apart from a stale one. CompileDiagnosticsTracker fills in the
+            // per-assembly CompilerMessages as compilation progresses and finishes.
+            var requestId = SessionState.GetInt(DiagRequestKey, 0) + 1;
+            SessionState.SetInt(DiagRequestKey, requestId);
+            SessionState.SetString(DiagStateKey, MiniJson.Serialize(new Dictionary<string, object>
+            {
+                ["status"] = "requested",
+                ["requestId"] = requestId,
+                ["errorCount"] = 0,
+                ["warningCount"] = 0,
+                ["messages"] = new List<object>()
+            }));
+
             AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             CompilationPipeline.RequestScriptCompilation();
             TrySyncSolution();
-            return new { status = "ok", message = "Asset database refreshed and compilation requested" };
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["message"] = "Asset database refreshed and compilation requested",
+                ["requestId"] = requestId
+            };
+        }
+
+        private static object HandleDiagnostics(string paramsJson)
+        {
+            var raw = SessionState.GetString(DiagStateKey, string.Empty);
+            if (string.IsNullOrEmpty(raw)
+                || !(MiniJson.Deserialize(raw) is Dictionary<string, object> state))
+            {
+                return new Dictionary<string, object>
+                {
+                    ["status"] = "idle",
+                    ["requestId"] = SessionState.GetInt(DiagRequestKey, 0),
+                    ["errorCount"] = 0,
+                    ["warningCount"] = 0,
+                    ["messages"] = new List<object>(),
+                    ["compiling"] = EditorApplication.isCompiling
+                };
+            }
+
+            // Surface live compile state too: a "completed" buffer while isCompiling is true means
+            // another compilation has already started after the one the CLI asked about.
+            state["compiling"] = EditorApplication.isCompiling;
+            return state;
+        }
+
+        internal static void WriteDiagnosticsState(string status, int errorCount, int warningCount, List<object> messages)
+        {
+            var truncated = messages.Count > MaxDiagnosticMessages;
+            var trimmed = truncated ? messages.GetRange(0, MaxDiagnosticMessages) : messages;
+            SessionState.SetString(DiagStateKey, MiniJson.Serialize(new Dictionary<string, object>
+            {
+                ["status"] = status,
+                ["requestId"] = SessionState.GetInt(DiagRequestKey, 0),
+                ["errorCount"] = errorCount,
+                ["warningCount"] = warningCount,
+                ["truncated"] = truncated,
+                ["messages"] = new List<object>(trimmed)
+            }));
         }
 
         private static object HandleRefresh(string paramsJson)
@@ -110,4 +177,73 @@ namespace UCP.Bridge
             }
         }
     }
+
+    /// <summary>
+    /// Captures per-assembly compiler messages so `compile` can report whether the build actually
+    /// succeeded instead of always claiming success. Subscribes once per domain load; accumulates
+    /// messages for the in-flight compilation in static fields (safe because a domain reload only
+    /// happens AFTER compilationFinished) and flushes them to SessionState, which persists across
+    /// the reload for the CLI to read once the editor settles.
+    /// </summary>
+    [InitializeOnLoad]
+    internal static class CompileDiagnosticsTracker
+    {
+        private static readonly List<object> s_messages = new List<object>();
+        private static int s_errorCount;
+        private static int s_warningCount;
+
+        static CompileDiagnosticsTracker()
+        {
+            CompilationPipeline.compilationStarted += OnCompilationStarted;
+            CompilationPipeline.assemblyCompilationFinished += OnAssemblyCompilationFinished;
+            CompilationPipeline.compilationFinished += OnCompilationFinished;
+        }
+
+        private static void OnCompilationStarted(object context)
+        {
+            s_messages.Clear();
+            s_errorCount = 0;
+            s_warningCount = 0;
+            CompilationController.WriteDiagnosticsState("compiling", 0, 0, s_messages);
+        }
+
+        private static void OnAssemblyCompilationFinished(string assemblyPath, CompilerMessage[] messages)
+        {
+            if (messages == null) return;
+            var assembly = Path.GetFileNameWithoutExtension(assemblyPath);
+            foreach (var message in messages)
+            {
+                string type;
+                switch (message.type)
+                {
+                    case CompilerMessageType.Error:
+                        type = "error";
+                        s_errorCount++;
+                        break;
+                    case CompilerMessageType.Warning:
+                        type = "warning";
+                        s_warningCount++;
+                        break;
+                    default:
+                        type = "info";
+                        break;
+                }
+
+                s_messages.Add(new Dictionary<string, object>
+                {
+                    ["assembly"] = assembly,
+                    ["type"] = type,
+                    ["message"] = message.message ?? string.Empty,
+                    ["file"] = message.file ?? string.Empty,
+                    ["line"] = message.line,
+                    ["column"] = message.column
+                });
+            }
+        }
+
+        private static void OnCompilationFinished(object context)
+        {
+            CompilationController.WriteDiagnosticsState("completed", s_errorCount, s_warningCount, s_messages);
+        }
+    }
 }

package/bridge/com.ucp.bridge/Editor/Controllers/ProfilerController.cs

@@ -15,6 +15,11 @@ namespace UCP.Bridge
     {
         private const int DefaultFrameListLimit = 20;
         private const int DefaultSummaryFrameWindow = 120;
+
+        // Summary aggregation walks every raw frame view on the main thread, so an unbounded
+        // range (e.g. --first-frame 0 on a long session) freezes the editor for seconds. Clamp it
+        // and say so in `warnings` rather than stalling.
+        private const int MaxSummaryFrameSpan = 600;
         private const int DefaultJsonExportFrameWindow = 120;
         private const int MaxThreadProbeCount = 128;
         private const long MinimumProfilerMemoryBytes = 16L * 1024L * 1024L;
@@ -296,6 +301,7 @@ namespace UCP.Bridge
             var limit = Math.Max(1, GetInt(parameters, "limit", 50));
             var sort = GetString(parameters, "sort") ?? "total-time";
             var maxDepth = GetNullableInt(parameters, "maxDepth");
+            var fields = GetFieldSet(parameters);
 
             using (var view = GetHierarchyFrameDataView(frameIndex, threadIndex))
             {
@@ -305,7 +311,8 @@ namespace UCP.Bridge
                 var items = CollectHierarchyItems(view, maxDepth);
                 items = SortHierarchyItems(items, sort);
 
-                var truncated = items.Count > limit;
+                var totalCount = items.Count;
+                var truncated = totalCount > limit;
                 if (truncated)
                     items = items.Take(limit).ToList();
 
@@ -315,8 +322,11 @@ namespace UCP.Bridge
                     ["thread"] = threadIndex,
                     ["sort"] = sort,
                     ["count"] = items.Count,
+                    // How many rows existed before truncation. Without it a caller cannot tell
+                    // "50 of 52" from "50 of 50,000", so it cannot decide whether to look further.
+                    ["totalCount"] = totalCount,
                     ["truncated"] = truncated,
-                    ["items"] = items.Select(item => (object)item.ToDictionary()).ToList(),
+                    ["items"] = items.Select(item => (object)ProjectFields(item.ToDictionary(), fields)).ToList(),
                     ["warnings"] = new List<object>()
                 };
             }
@@ -330,6 +340,7 @@ namespace UCP.Bridge
             var limit = Math.Max(1, GetInt(parameters, "limit", 200));
             var maxDepth = GetNullableInt(parameters, "maxDepth");
             var includeMetadata = GetBool(parameters, "includeMetadata", false);
+            var fields = GetFieldSet(parameters);
 
             using (var view = GetRawFrameDataView(frameIndex, threadIndex))
             {
@@ -337,7 +348,8 @@ namespace UCP.Bridge
                     throw new ArgumentException($"Raw profiler data is unavailable for frame {frameIndex}, thread {threadIndex}");
 
                 var samples = CollectTimelineSamples(view, maxDepth, includeMetadata);
-                var truncated = samples.Count > limit;
+                var totalCount = samples.Count;
+                var truncated = totalCount > limit;
                 if (truncated)
                     samples = samples.Take(limit).ToList();
 
@@ -346,8 +358,9 @@ namespace UCP.Bridge
                     ["frame"] = frameIndex,
                     ["thread"] = threadIndex,
                     ["count"] = samples.Count,
+                    ["totalCount"] = totalCount,
                     ["truncated"] = truncated,
-                    ["samples"] = samples.Cast<object>().ToList(),
+                    ["samples"] = samples.Select(sample => (object)ProjectFields(sample, fields)).ToList(),
                     ["warnings"] = new List<object>()
                 };
             }
@@ -427,10 +440,23 @@ namespace UCP.Bridge
             if (firstFrame > lastFrame)
                 throw new ArgumentException("Requested frame range is empty");
 
+            var warnings = new List<object>();
+            var span = lastFrame - firstFrame + 1;
+            if (span > MaxSummaryFrameSpan)
+            {
+                // Aggregation runs on the editor's main thread; a huge span stalls the whole
+                // editor. Keep the most recent frames, which is what callers almost always want.
+                firstFrame = lastFrame - MaxSummaryFrameSpan + 1;
+                warnings.Add(
+                    $"Requested {span} frames; aggregated the most recent {MaxSummaryFrameSpan} " +
+                    $"(frames {firstFrame}-{lastFrame}) to avoid stalling the editor. " +
+                    "Narrow the range with --first-frame/--last-frame for older windows.");
+            }
+
             return new Dictionary<string, object>
             {
                 ["summary"] = BuildSummaryData(limit, threadIndex, firstFrame, lastFrame),
-                ["warnings"] = new List<object>()
+                ["warnings"] = warnings
             };
         }
 
@@ -1365,6 +1391,55 @@ namespace UCP.Bridge
                 StringComparison.OrdinalIgnoreCase);
         }
 
+        /// <summary>
+        /// Optional caller-supplied field allow-list (`fields: ["name","selfMs"]`). Profiler rows
+        /// are wide and agents pay per token for columns they never read, so let them ask for the
+        /// two or three they actually want. Null means "every field".
+        /// </summary>
+        private static HashSet<string> GetFieldSet(Dictionary<string, object> parameters)
+        {
+            if (parameters == null || !parameters.TryGetValue("fields", out var raw) || raw == null)
+                return null;
+
+            var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            if (raw is List<object> list)
+            {
+                foreach (var entry in list)
+                {
+                    var name = entry?.ToString();
+                    if (!string.IsNullOrWhiteSpace(name)) set.Add(name.Trim());
+                }
+            }
+            else
+            {
+                foreach (var name in raw.ToString().Split(','))
+                {
+                    if (!string.IsNullOrWhiteSpace(name)) set.Add(name.Trim());
+                }
+            }
+
+            return set.Count == 0 ? null : set;
+        }
+
+        /// Narrow one row to the requested fields. Unknown names are ignored rather than erroring,
+        /// so a caller can ask for a superset across profiler surfaces without branching.
+        private static Dictionary<string, object> ProjectFields(
+            Dictionary<string, object> row,
+            HashSet<string> fields)
+        {
+            if (fields == null || row == null) return row;
+
+            var projected = new Dictionary<string, object>();
+            foreach (var pair in row)
+            {
+                if (fields.Contains(pair.Key)) projected[pair.Key] = pair.Value;
+            }
+
+            // Never hand back an empty row: a caller that misspelled every field would otherwise
+            // get a silent wall of `{}` instead of a usable result.
+            return projected.Count == 0 ? row : projected;
+        }
+
         private static Dictionary<string, object> BuildSummaryData(
             int limit,
             int threadIndex,

package/bridge/com.ucp.bridge/Editor/Controllers/SceneController.cs

@@ -168,19 +168,41 @@ namespace UCP.Bridge
             sceneView.Repaint();
             SceneView.RepaintAll();
 
+            ResolveSceneViewCamera(sceneView, out var cameraPosition, out var cameraRotation);
+
             return new Dictionary<string, object>
             {
                 ["status"] = "ok",
                 ["instanceId"] = instanceId,
                 ["name"] = target.name,
                 ["pivot"] = VectorToList(sceneView.pivot),
-                ["cameraPosition"] = VectorToList(sceneView.camera.transform.position),
-                ["cameraRotationEuler"] = VectorToList(sceneView.camera.transform.rotation.eulerAngles),
+                ["cameraPosition"] = VectorToList(cameraPosition),
+                ["cameraRotationEuler"] = VectorToList(cameraRotation.eulerAngles),
                 ["size"] = sceneView.size,
                 ["axis"] = axis.HasValue ? VectorToList(axis.Value.normalized) : null
             };
         }
 
+        /// <summary>
+        /// Derive the Scene view camera pose from the authoritative view state
+        /// (<c>pivot</c>/<c>rotation</c>/<c>cameraDistance</c>) rather than reading
+        /// <c>sceneView.camera.transform</c>.
+        ///
+        /// <c>LookAtDirect</c> updates the view state immediately, but the camera transform is only
+        /// synced when the Scene view actually repaints. <c>Repaint()</c> merely queues that, so in
+        /// batch mode - and for any caller reading the response in the same frame as the focus -
+        /// the camera transform still holds the *previous* pose and the reported values were simply
+        /// wrong.
+        /// </summary>
+        private static void ResolveSceneViewCamera(
+            SceneView sceneView,
+            out Vector3 position,
+            out Quaternion rotation)
+        {
+            rotation = sceneView.rotation;
+            position = sceneView.pivot - (rotation * Vector3.forward) * sceneView.cameraDistance;
+        }
+
         private static Vector3? TryReadAxis(Dictionary<string, object> parameters)
         {
             if (parameters == null || !parameters.TryGetValue("axis", out var axisObj) || axisObj == null)

package/bridge/com.ucp.bridge/Editor/Controllers/ScriptController.cs

@@ -12,29 +12,35 @@ namespace UCP.Bridge
             router.Register("exec/run", HandleRun);
         }
 
-        private static List<IUCPScript> DiscoverScripts()
+        /// <summary>
+        /// Implementing types, cached for the lifetime of the app domain. The scan itself is the
+        /// expensive part -- `GetTypes()` over every loaded assembly -- and its result cannot go
+        /// stale without a domain reload, which resets this static anyway.
+        /// </summary>
+        private static Type[] s_scriptTypes;
+
+        private static Type[] DiscoverScriptTypes()
         {
-            var scripts = new List<IUCPScript>();
+            if (s_scriptTypes != null) return s_scriptTypes;
+
             var interfaceType = typeof(IUCPScript);
+            var bridgeAssemblyName = interfaceType.Assembly.GetName().Name;
+            var types = new List<Type>();
 
             foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
             {
+                // A type can only implement IUCPScript if its assembly references the one that
+                // declares it. Checking cheap reference metadata first avoids materialising the
+                // full type list of every framework and Unity assembly in the domain.
+                if (assembly != interfaceType.Assembly && !ReferencesAssembly(assembly, bridgeAssemblyName))
+                    continue;
+
                 try
                 {
                     foreach (var type in assembly.GetTypes())
                     {
                         if (interfaceType.IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface)
-                        {
-                            try
-                            {
-                                var instance = (IUCPScript)Activator.CreateInstance(type);
-                                scripts.Add(instance);
-                            }
-                            catch (Exception ex)
-                            {
-                                Debug.LogWarning($"[UCP] Failed to instantiate script {type.Name}: {ex.Message}");
-                            }
-                        }
+                            types.Add(type);
                     }
                 }
                 catch (System.Reflection.ReflectionTypeLoadException)
@@ -43,9 +49,71 @@ namespace UCP.Bridge
                 }
             }
 
+            s_scriptTypes = types.ToArray();
+            return s_scriptTypes;
+        }
+
+        private static bool ReferencesAssembly(System.Reflection.Assembly assembly, string name)
+        {
+            try
+            {
+                foreach (var reference in assembly.GetReferencedAssemblies())
+                {
+                    if (string.Equals(reference.Name, name, StringComparison.Ordinal)) return true;
+                }
+            }
+            catch
+            {
+                // Dynamic assemblies can refuse to report references; treat them as non-matching.
+            }
+
+            return false;
+        }
+
+        private static IUCPScript Instantiate(Type type)
+        {
+            try
+            {
+                return (IUCPScript)Activator.CreateInstance(type);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"[UCP] Failed to instantiate script {type.Name}: {ex.Message}");
+                return null;
+            }
+        }
+
+        private static List<IUCPScript> DiscoverScripts()
+        {
+            var scripts = new List<IUCPScript>();
+            foreach (var type in DiscoverScriptTypes())
+            {
+                var instance = Instantiate(type);
+                if (instance != null) scripts.Add(instance);
+            }
+
             return scripts;
         }
 
+        /// <summary>
+        /// Resolve one script by name, stopping at the first match.
+        /// `Name` is an instance member, so candidates must be constructed to be identified --
+        /// but running *every* script's constructor to invoke one of them is a side effect nobody
+        /// asked for, so stop as soon as the target is found.
+        /// </summary>
+        private static IUCPScript FindScript(string name)
+        {
+            foreach (var type in DiscoverScriptTypes())
+            {
+                var instance = Instantiate(type);
+                if (instance == null) continue;
+                if (string.Equals(instance.Name, name, StringComparison.OrdinalIgnoreCase))
+                    return instance;
+            }
+
+            return null;
+        }
+
         private static object HandleList(string paramsJson)
         {
             var scripts = DiscoverScripts();
@@ -78,16 +146,7 @@ namespace UCP.Bridge
             if (p.TryGetValue("params", out var paramsObj) && paramsObj != null)
                 scriptParams = MiniJson.Serialize(paramsObj);
 
-            var scripts = DiscoverScripts();
-            IUCPScript target = null;
-            foreach (var s in scripts)
-            {
-                if (string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase))
-                {
-                    target = s;
-                    break;
-                }
-            }
+            var target = FindScript(name);
 
             if (target == null)
                 throw new ArgumentException($"Script not found: {name}. Use exec/list to see available scripts.");