@mflrevan/ucp 0.6.0 → 0.6.2

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.6.0` of the Unity Control Protocol CLI.
+Version `0.6.2` 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/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.6.2] - 2026-08-31
+
+### Added
+
+- Added native, scene-object-free `record/start`, `record/stop`, `record/status`, `record/arm`, and
+  `record/signal` RPCs for Game and Scene view video capture.
+- Added aspect-preserving longest-edge sizing and explicit width/height canvases with letterboxing,
+  even-dimension normalization, configurable FPS/bitrate/duration, H.264/MP4 and VP8/WebM encoding,
+  and platform-aware format selection.
+- Added play-enter, play-exit, bounded log-regex, and named-signal triggers. Armed play triggers use
+  `SessionState` to survive domain reloads, and `record/stop` also cancels a pending trigger.
+- Added a `slowdown` parameter to `record/start` and `record/arm`. Frames are still captured at the
+  requested cadence in real time; only the encoder's declared frame rate is divided by the factor, so
+  playback is stretched without duplicating frames or re-encoding. `record/status` reports both
+  `slowdown` and the resulting `playbackFps`. Values outside 1-20 are rejected. This raises effective
+  temporal resolution for consumers that sample a clip at a fixed low rate rather than playing it.
+- Documented that `record/start --view game` resolves `Camera.main`, not the Game view's composited
+  camera stack. Projects rendering through several enabled cameras record only the `MainCamera`-tagged
+  one, and camera depth does not change the selection; `--view scene` captures the Scene view camera,
+  which is unaffected by gameplay.
+
+### Fixed
+
+- Fixed `tests/run` counting an empty root suite as a passed test. When a filter matched nothing,
+  the run finished with a childless root whose result was collected as a leaf, so the summary
+  reported one passed test named after the project. Suite results are now skipped, so a run that
+  executed nothing reports a total of zero.
+- Changed `tests/run` filtering from `Filter.testNames` to `Filter.groupNames`. `testNames` requires
+  an exact fully-qualified match, which silently selected nothing for a class or method name;
+  `groupNames` is matched as a regular expression against each test's full name, so partial names
+  select what a caller expects and fully-qualified names still match.
+- Fixed `object/get-property` double-converting values that `SerializedPropertyToValue` had already
+  shaped for JSON. `GetPropertyValue` resolves a name through `SerializedObject.FindProperty` first
+  and returns a ready `List`/`Dictionary`; `ConvertToJson` then ran over that result, matched none
+  of its cases, and fell through to `value.ToString()`. A `Vector3` field came back as
+  ``"System.Collections.Generic.List`1[System.Object]"`` with
+  ``"type": "List`1"``. Every serialized Vector2/3/4, Quaternion, Color, Rect, Bounds and
+  object-reference field was affected, and float fields reported a `Double` type name.
+  `get-property` now takes its type name from the `SerializedProperty` so it agrees with
+  `get-fields`, converts only values read through the reflection fallback, and `ConvertToJson` is
+  idempotent for already-shaped `IList`/`IDictionary` values.
+
+### Performance
+
+- Frames render through a hidden reusable `RenderTexture` and reusable CPU readback texture into
+  Unity's native `MediaEncoder`; recording creates no scene objects or scripts and avoids per-frame
+  managed texture allocation.
+
+### Reliability
+
+- Added sibling `.partial` output and final rename, explicit overwrite handling, extension/format
+  validation, encoder and temporary-file cleanup on failure, detached safety deadlines, trigger wait
+  deadlines, dropped-frame accounting, and structured completed/failed status metadata.
+- Active encoders finalize during assembly reload or editor shutdown. Play-boundary capture is
+  handled by the persisted `play-enter`/`play-exit` arm flow rather than attempting to retain a
+  native encoder across a domain reload.
+
+### Tests
+
+- Added editor smoke tests for recording RPC registration and idle status, aspect-preserving even
+  dimensions, signal matching, and cancellation of armed recordings.
+
 ## [0.4.1] - 2026-03-21
 
 ### Added

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.2";
 
         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
                 };
             });
 
@@ -121,6 +142,9 @@ namespace UCP.Bridge
             // Screenshots
             ScreenshotController.Register(s_router);
 
+            // Lightweight video recording
+            RecordingController.Register(s_router);
+
             // Logs
             LogsController.Register(s_router);
 
@@ -393,12 +417,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);
@@ -478,6 +512,7 @@ namespace UCP.Bridge
 
         private static void OnLogMessage(string message, string stackTrace, LogType type)
         {
+            RecordingController.NotifyLog(message);
             // Don't forward our own log messages to avoid infinite recursion
             if (message.StartsWith("[UCP]")) return;
 
@@ -544,6 +579,8 @@ namespace UCP.Bridge
 
             Debug.Log("[UCP] Bridge server shutting down");
 
+            RecordingController.Shutdown();
+
             s_cts?.Cancel();
 
             // Stop listener first to release port immediately

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/PropertyController.cs

@@ -77,14 +77,14 @@ namespace UCP.Bridge
             var comp = FindComponent(go, cObj.ToString());
             string propName = propObj.ToString();
 
-            var value = GetPropertyValue(comp, propName);
+            var value = GetPropertyValue(comp, propName, out var typeName);
             return new Dictionary<string, object>
             {
                 ["instanceId"] = instanceId,
                 ["component"] = cObj.ToString(),
                 ["property"] = propName,
-                ["value"] = ConvertToJson(value),
-                ["type"] = value != null ? value.GetType().Name : "null"
+                ["value"] = value,
+                ["type"] = typeName
             };
         }
 
@@ -277,7 +277,7 @@ namespace UCP.Bridge
             }
         }
 
-        private static object GetPropertyValue(Component comp, string propertyName)
+        private static object GetPropertyValue(Component comp, string propertyName, out string typeName)
         {
             var so = new SerializedObject(comp);
             try
@@ -285,22 +285,35 @@ namespace UCP.Bridge
                 so.Update();
                 var prop = so.FindProperty(propertyName);
                 if (prop != null)
+                {
+                    // Already JSON-shaped -- reporting its type from the SerializedProperty keeps
+                    // `get-property` and `get-fields` describing the same field the same way.
+                    typeName = prop.propertyType.ToString();
                     return SerializedPropertyToValue(prop);
+                }
             }
             finally
             {
                 so.Dispose();
             }
 
-            // Fallback to reflection
+            // Fallback to reflection for names Unity does not serialize (e.g. Transform.position).
             var type = comp.GetType();
             var fi = type.GetField(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             if (fi != null)
-                return fi.GetValue(comp);
+            {
+                var raw = fi.GetValue(comp);
+                typeName = raw != null ? raw.GetType().Name : fi.FieldType.Name;
+                return ConvertToJson(raw);
+            }
 
             var pi = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
             if (pi != null && pi.CanRead)
-                return pi.GetValue(comp);
+            {
+                var raw = pi.GetValue(comp);
+                typeName = raw != null ? raw.GetType().Name : pi.PropertyType.Name;
+                return ConvertToJson(raw);
+            }
 
             throw new ArgumentException($"Property '{propertyName}' not found on {type.Name}");
         }
@@ -488,6 +501,9 @@ namespace UCP.Bridge
                 return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
             if (value is UnityEngine.Object uObj)
                 return ObjectReferenceResolver.Serialize(uObj);
+            // Values that are already JSON-shaped pass through untouched.
+            if (value is IList || value is IDictionary)
+                return value;
             return value.ToString();
         }