@mflrevan/ucp 0.6.0 → 0.6.2

package/bridge/com.ucp.bridge/Tests/Editor/ControllerSmokeTests.cs

@@ -46,6 +46,7 @@ namespace UCP.Bridge.Tests
             PlayModeController.Register(_router);
             ReferenceController.Register(_router);
             LogsController.Register(_router);
+            RecordingController.Register(_router);
             HierarchyController.Register(_router);
             ProfilerController.Register(_router);
             PropertyController.Register(_router);
@@ -72,6 +73,7 @@ namespace UCP.Bridge.Tests
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
             LogsController.ClearHistoryForTests();
+            RecordingController.ResetForTests();
             AssetImportSupport.ClearTestState();
             Profiler.enabled = false;
             Profiler.enableBinaryLog = false;
@@ -97,6 +99,7 @@ namespace UCP.Bridge.Tests
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
             LogsController.ClearHistoryForTests();
+            RecordingController.ResetForTests();
             AssetImportSupport.ClearTestState();
             Profiler.enabled = false;
             Profiler.enableBinaryLog = false;
@@ -123,6 +126,115 @@ namespace UCP.Bridge.Tests
             Assert.That(Convert.ToBoolean(capabilities["sessionControl"]), Is.True);
         }
 
+        [Test]
+        public void RecordingController_RegistersLifecycleMethodsAndReportsIdle()
+        {
+            Assert.That(_router.HasMethod("record/start"), Is.True);
+            Assert.That(_router.HasMethod("record/stop"), Is.True);
+            Assert.That(_router.HasMethod("record/status"), Is.True);
+            Assert.That(_router.HasMethod("record/arm"), Is.True);
+            Assert.That(_router.HasMethod("record/signal"), Is.True);
+
+            var response = _router.Dispatch("record/status", 1, "{}");
+            Assert.That(response.error, Is.Null);
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(result["state"], Is.EqualTo("idle"));
+        }
+
+        [Test]
+        public void RecordingController_ResolvesEvenAspectPreservingDimensions()
+        {
+            Assert.That(RecordingController.ResolveDimensionsForTests(16f / 9f, 960, null, null),
+                Is.EqualTo((960, 540)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(9f / 16f, 960, null, null),
+                Is.EqualTo((540, 960)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(4f / 3f, 960, 640, null),
+                Is.EqualTo((640, 480)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(4f / 3f, 960, null, 600),
+                Is.EqualTo((800, 600)));
+        }
+
+        [Test]
+        public void RecordingController_ArmsAndMatchesNamedSignal()
+        {
+            var response = _router.Dispatch(
+                "record/arm",
+                1,
+                "{\"trigger\":\"signal:not-this-one\",\"duration\":1,\"timeout\":5}");
+            Assert.That(response.error, Is.Null);
+
+            var signal = _router.Dispatch("record/signal", 2, "{\"name\":\"different\"}");
+            Assert.That(signal.error, Is.Null);
+            var result = (Dictionary<string, object>)signal.result;
+            Assert.That(Convert.ToBoolean(result["matched"]), Is.False);
+            Assert.That(result["state"], Is.EqualTo("armed"));
+
+            var stop = _router.Dispatch("record/stop", 3, "{}");
+            Assert.That(stop.error, Is.Null);
+            var stopped = (Dictionary<string, object>)stop.result;
+            Assert.That(stopped["state"], Is.EqualTo("idle"));
+        }
+
+        [Test]
+        public void GetProperty_ReturnsCompositeValuesRatherThanTypeNames()
+        {
+            // Regression: when SerializedObject.FindProperty resolves a name, the value it returns
+            // is already JSON-shaped. That result used to be converted a second time, match no
+            // case, and fall through to value.ToString() -- so a Vector3 arrived as
+            // "System.Collections.Generic.List`1[System.Object]". Querying the serialized name
+            // (m_LocalPosition) is what forces the FindProperty path; the public alias (position)
+            // has no serialized entry and takes the reflection fallback instead, which is why that
+            // one never looked broken.
+            var go = new GameObject("UcpPropertyProbe");
+            try
+            {
+                go.transform.localPosition = new Vector3(1.5f, 2.5f, 3.5f);
+                var id = go.GetInstanceID();
+
+                var serialized = _router.Dispatch("object/get-property", 1, "{\"instanceId\":ID,\"component\":\"Transform\",\"property\":\"m_LocalPosition\"}".Replace("ID", id.ToString()));
+                Assert.That(serialized.error, Is.Null);
+                var serializedResult = (Dictionary<string, object>)serialized.result;
+                var localPosition = serializedResult["value"] as IList;
+                Assert.That(localPosition, Is.Not.Null,
+                    "a serialized Vector3 must come back as an array, not a stringified type name");
+                Assert.That(localPosition.Count, Is.EqualTo(3));
+                Assert.That(Convert.ToDouble(localPosition[0]), Is.EqualTo(1.5d).Within(1e-4));
+                Assert.That(Convert.ToDouble(localPosition[2]), Is.EqualTo(3.5d).Within(1e-4));
+                Assert.That(serializedResult["type"], Is.EqualTo("Vector3"),
+                    "type must describe the field, not the container it was shaped into");
+
+                // Reflection fallback: no serialized entry named "position".
+                var reflected = _router.Dispatch("object/get-property", 2, "{\"instanceId\":ID,\"component\":\"Transform\",\"property\":\"position\"}".Replace("ID", id.ToString()));
+                Assert.That(reflected.error, Is.Null);
+                var reflectedResult = (Dictionary<string, object>)reflected.result;
+                Assert.That(reflectedResult["value"] as IList, Is.Not.Null);
+                Assert.That(reflectedResult["type"], Is.EqualTo("Vector3"));
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(go);
+            }
+        }
+
+        [Test]
+        public void RecordingController_ValidatesSlowdownRange()
+        {
+            // --slowdown exists to raise effective temporal resolution for models that sample a
+            // clip at a fixed low rate, so an out-of-range factor must fail loudly rather than
+            // silently producing a file whose playback rate is meaningless.
+            var tooLarge = _router.Dispatch("record/arm", 1, "{\"trigger\":\"signal:sd\",\"duration\":1,\"timeout\":5,\"slowdown\":40}");
+            Assert.That(tooLarge.error, Is.Not.Null, "a slowdown above the supported range must be rejected");
+
+            var accepted = _router.Dispatch("record/arm", 2, "{\"trigger\":\"signal:sd\",\"duration\":1,\"timeout\":5,\"slowdown\":6}");
+            Assert.That(accepted.error, Is.Null);
+            var armed = (Dictionary<string, object>)accepted.result;
+            Assert.That(armed["state"], Is.EqualTo("armed"));
+
+            var stop = _router.Dispatch("record/stop", 3, "{}");
+            Assert.That(stop.error, Is.Null);
+            Assert.That(((Dictionary<string, object>)stop.result)["state"], Is.EqualTo("idle"));
+        }
+
         [Test]
         public void ProfilerSessionStartStop_TogglesProfilerState()
         {
@@ -307,10 +419,48 @@ namespace UCP.Bridge.Tests
             var status = _router.Dispatch("logs/status", 1, "{}");
             Assert.That(status.error, Is.Null);
 
-            var result = (Dictionary<string, object>)status.result;
-            var byLevel = (Dictionary<string, object>)result["byLevel"];
-            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(0));
-            Assert.That(Convert.ToInt32(byLevel["exception"]), Is.EqualTo(0));
+            Assert.That(status.result, Is.InstanceOf<Dictionary<string, object>>());
+
+            // Assert on the specific regression this test exists for -- `asset/search` loading
+            // `.unity` files through LoadAllAssetsAtPath, which makes Unity emit
+            // "Do not use ReadObjectThreaded on scene objects!" -- rather than on "zero errors of
+            // any kind". A blanket count also catches unrelated editor noise: on a cold Library the
+            // search pulls in lazy imports whose URP shader-fallback errors have nothing to do with
+            // this code path, which made the whole release matrix red on every Unity version.
+            var problems = BufferedProblems();
+            var threadedReadErrors = problems
+                .FindAll(entry => entry.Contains("ReadObjectThreaded"));
+
+            Assert.That(
+                threadedReadErrors,
+                Is.Empty,
+                () => "asset/search emitted threaded scene-read errors:" + NewLineIndent
+                    + string.Join(NewLineIndent, threadedReadErrors));
+        }
+
+        private const string NewLineIndent = "\n  ";
+
+        /// Buffered error/exception entries, as "[level] message" strings.
+        private List<string> BufferedProblems()
+        {
+            var lines = new List<string>();
+            var tail = _router.Dispatch("logs/tail", 1, "{\"count\":200}");
+            if (tail.error != null || tail.result is not Dictionary<string, object> payload)
+                return lines;
+
+            if (!payload.TryGetValue("logs", out var logsObj) || logsObj is not List<object> logs)
+                return lines;
+
+            foreach (var item in logs)
+            {
+                if (item is not Dictionary<string, object> entry) continue;
+                var level = entry.TryGetValue("level", out var l) ? l?.ToString() : null;
+                if (level != "error" && level != "exception") continue;
+                var message = entry.TryGetValue("messagePreview", out var m) ? m?.ToString() : "";
+                lines.Add($"[{level}] {message}");
+            }
+
+            return lines;
         }
 
         [Test]
@@ -1142,9 +1292,33 @@ namespace UCP.Bridge.Tests
                 System.Convert.ToSingle(axisData[0]),
                 System.Convert.ToSingle(axisData[1]),
                 System.Convert.ToSingle(axisData[2]));
-            var actualForward = sceneView.camera.transform.forward;
             Assert.That(Vector3.Dot(returnedAxis.normalized, expectedDirection), Is.GreaterThan(0.98f));
-            Assert.That(Mathf.Abs(Vector3.Dot(actualForward.normalized, expectedDirection)), Is.GreaterThan(0.98f));
+
+            // Assert against the Scene view's own state and the reported pose, not
+            // `sceneView.camera.transform`: that transform is only synced when the view repaints,
+            // so in batch mode it still holds the pre-focus pose and this check used to fail.
+            var viewForward = sceneView.rotation * Vector3.forward;
+            Assert.That(Mathf.Abs(Vector3.Dot(viewForward.normalized, expectedDirection)), Is.GreaterThan(0.98f));
+
+            var eulerData = (List<object>)result["cameraRotationEuler"];
+            var reportedForward = Quaternion.Euler(
+                System.Convert.ToSingle(eulerData[0]),
+                System.Convert.ToSingle(eulerData[1]),
+                System.Convert.ToSingle(eulerData[2])) * Vector3.forward;
+            Assert.That(
+                Mathf.Abs(Vector3.Dot(reportedForward.normalized, expectedDirection)),
+                Is.GreaterThan(0.98f),
+                "scene/focus must report the pose it just applied, not the last rendered one");
+
+            // The reported camera must sit behind the pivot along its own forward axis.
+            var positionData = (List<object>)result["cameraPosition"];
+            var reportedPosition = new Vector3(
+                System.Convert.ToSingle(positionData[0]),
+                System.Convert.ToSingle(positionData[1]),
+                System.Convert.ToSingle(positionData[2]));
+            Assert.That(Vector3.Dot((sceneView.pivot - reportedPosition).normalized, reportedForward.normalized),
+                Is.GreaterThan(0.98f));
+
             Assert.That(Vector3.Distance(sceneView.pivot, cube.transform.position), Is.LessThan(2f));
         }
 
@@ -1585,4 +1759,5 @@ namespace UCP.Bridge.Tests
             public SearchRootAsset referenceAsset;
         }
     }
+
 }

package/bridge/com.ucp.bridge/Tests/Editor/MiniJsonSerializerTests.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UCP.Bridge.Tests
+{
+    /// <summary>
+    /// Regression coverage for the serializer that turns arbitrary <see cref="IUCPScript"/> return
+    /// values into JSON. The reflection walk used to be unbounded, so returning anything holding a
+    /// UnityEngine math struct (Vector3.normalized returns another Vector3, forever) overflowed the
+    /// stack -- which .NET cannot catch and which killed the editor process outright.
+    /// </summary>
+    public class MiniJsonSerializerTests
+    {
+        private static Dictionary<string, object> Roundtrip(object value)
+        {
+            var json = MiniJson.Serialize(new { value });
+            var parsed = MiniJson.Deserialize(json) as Dictionary<string, object>;
+            Assert.IsNotNull(parsed, $"Serializer produced unparseable JSON: {json}");
+            return parsed;
+        }
+
+        [Test]
+        public void SerializesVector3WithoutStackOverflow()
+        {
+            // The original crash repro: `return new { pos = Vector3.zero }` from a UCP script.
+            var json = MiniJson.Serialize(new { pos = Vector3.zero });
+
+            Assert.AreEqual("{\"pos\":{\"x\":0,\"y\":0,\"z\":0}}", json);
+        }
+
+        [Test]
+        public void SerializesUnityMathStructsAsPlainShapes()
+        {
+            Assert.AreEqual("{\"x\":1,\"y\":2}", MiniJson.Serialize(new Vector2(1f, 2f)));
+            Assert.AreEqual("{\"x\":1,\"y\":2,\"z\":3,\"w\":4}", MiniJson.Serialize(new Vector4(1f, 2f, 3f, 4f)));
+            Assert.AreEqual("{\"x\":0,\"y\":0,\"z\":0,\"w\":1}", MiniJson.Serialize(Quaternion.identity));
+            Assert.AreEqual("{\"r\":1,\"g\":0,\"b\":0,\"a\":1}", MiniJson.Serialize(Color.red));
+            Assert.AreEqual("{\"x\":1,\"y\":2,\"z\":3}", MiniJson.Serialize(new Vector3Int(1, 2, 3)));
+            Assert.AreEqual(
+                "{\"x\":1,\"y\":2,\"width\":3,\"height\":4}",
+                MiniJson.Serialize(new Rect(1f, 2f, 3f, 4f)));
+            Assert.AreEqual(
+                "{\"center\":{\"x\":0,\"y\":0,\"z\":0},\"size\":{\"x\":2,\"y\":2,\"z\":2}}",
+                MiniJson.Serialize(new Bounds(Vector3.zero, Vector3.one * 2f)));
+        }
+
+        [Test]
+        public void SerializesQuaternionNestedInAnonymousResult()
+        {
+            var parsed = Roundtrip(new { rot = Quaternion.Euler(0f, 90f, 0f), pos = Vector3.one });
+            Assert.IsInstanceOf<Dictionary<string, object>>(parsed["value"]);
+        }
+
+        [Test]
+        public void SerializesUnityObjectAsIdentityInsteadOfWalkingTheSceneGraph()
+        {
+            var go = new GameObject("MiniJsonProbe");
+            try
+            {
+                // GameObject.transform.gameObject is a cycle; walking it never terminates.
+                var parsed = Roundtrip(go);
+                var identity = (Dictionary<string, object>)parsed["value"];
+
+                Assert.AreEqual("MiniJsonProbe", identity["name"]);
+                Assert.AreEqual("GameObject", identity["type"]);
+                Assert.IsTrue(identity.ContainsKey("instanceId"));
+
+                // Components are the same story via Component.gameObject.
+                var componentJson = MiniJson.Serialize(go.transform);
+                Assert.IsTrue(componentJson.Contains("\"type\":\"Transform\""), componentJson);
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(go);
+            }
+        }
+
+        [Test]
+        public void DestroyedUnityObjectSerializesAsNull()
+        {
+            var go = new GameObject("MiniJsonDestroyed");
+            UnityEngine.Object.DestroyImmediate(go);
+
+            Assert.AreEqual("{\"value\":null}", MiniJson.Serialize(new { value = go }));
+        }
+
+        [Test]
+        public void ReferenceCyclesAreBrokenInsteadOfRecursingForever()
+        {
+            var a = new Node { Label = "a" };
+            var b = new Node { Label = "b", Next = a };
+            a.Next = b;
+
+            var json = MiniJson.Serialize(a);
+
+            Assert.IsTrue(json.Contains("<ucp:cycle>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void SelfReferencingDictionaryIsBroken()
+        {
+            var dict = new Dictionary<string, object> { ["name"] = "root" };
+            dict["self"] = dict;
+
+            var json = MiniJson.Serialize(dict);
+
+            Assert.IsTrue(json.Contains("<ucp:cycle>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void UnboundedComputedPropertyRecursionIsDepthCapped()
+        {
+            // Mirrors the Vector3.normalized shape for a type the serializer has no special case
+            // for: every read allocates a fresh instance, so reference tracking cannot help and
+            // only the depth cap prevents a stack overflow.
+            var json = MiniJson.Serialize(new Fractal());
+
+            Assert.IsTrue(json.Contains("<ucp:max-depth>"), json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void ThrowingGetterDoesNotCorruptTheDocument()
+        {
+            var json = MiniJson.Serialize(new Explosive());
+
+            Assert.IsFalse(json.Contains("boom"), json);
+            var parsed = MiniJson.Deserialize(json) as Dictionary<string, object>;
+            Assert.IsNotNull(parsed, json);
+            Assert.AreEqual("ok", parsed["safe"]);
+        }
+
+        [Test]
+        public void NonFiniteFloatsSerializeAsNullRatherThanInvalidJson()
+        {
+            // Degenerate bounds and zero-length normalize hand out NaN routinely; raw NaN/Infinity
+            // are not valid JSON and made the whole response unparseable on the CLI side.
+            var json = MiniJson.Serialize(new { a = float.NaN, b = float.PositiveInfinity, c = double.NaN });
+
+            Assert.AreEqual("{\"a\":null,\"b\":null,\"c\":null}", json);
+            Assert.IsNotNull(MiniJson.Deserialize(json));
+        }
+
+        [Test]
+        public void UnsignedAndWideIntegersSerializeAsNumbers()
+        {
+            var json = MiniJson.Serialize(new { a = (uint)7, b = (ushort)8, c = (byte)9, d = 10UL });
+
+            Assert.AreEqual("{\"a\":7,\"b\":8,\"c\":9,\"d\":10}", json);
+        }
+
+        [Test]
+        public void NonListEnumerablesSerializeAsArrays()
+        {
+            var json = MiniJson.Serialize(new { items = new HashSet<int> { 1 } });
+
+            Assert.AreEqual("{\"items\":[1]}", json);
+        }
+
+        [Test]
+        public void EnumsStillSerializeAsIntegers()
+        {
+            Assert.AreEqual("{\"value\":2}", MiniJson.Serialize(new { value = SampleEnum.Two }));
+        }
+
+        [Test]
+        public void ParserRejectsTruncatedInputInsteadOfHanging()
+        {
+            // A truncated string literal used to spin the reader on end-of-input forever, wedging
+            // the editor's main thread.
+            Assert.Throws<FormatException>(() => MiniJson.Deserialize("{\"a\": \"unterminated"));
+        }
+
+        [Test]
+        public void ParserRejectsPathologicallyNestedInput()
+        {
+            var deep = new string('[', 1000);
+            Assert.Throws<FormatException>(() => MiniJson.Deserialize(deep));
+        }
+
+        [Test]
+        public void OrdinaryPayloadsAreUnchanged()
+        {
+            var json = MiniJson.Serialize(new Dictionary<string, object>
+            {
+                ["name"] = "cube",
+                ["active"] = true,
+                ["children"] = new List<object> { 1L, 2.5, null },
+            });
+
+            Assert.AreEqual("{\"name\":\"cube\",\"active\":true,\"children\":[1,2.5,null]}", json);
+        }
+
+        private enum SampleEnum
+        {
+            One = 1,
+            Two = 2,
+        }
+
+        private sealed class Node
+        {
+            public string Label;
+            public Node Next;
+        }
+
+        private sealed class Fractal
+        {
+            public Fractal Child => new Fractal();
+        }
+
+        private sealed class Explosive
+        {
+            public string Safe => "ok";
+            public string Boom => throw new InvalidOperationException("boom");
+        }
+    }
+}

package/bridge/com.ucp.bridge/Tests/Editor/MiniJsonSerializerTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5082955dbcce78c4986000348e3a5d92

package/bridge/com.ucp.bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "displayName": "Unity Control Protocol Bridge",
   "description": "WebSocket bridge for programmatic Unity Editor control via CLI and AI agents.",
   "unity": "2021.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mflrevan/ucp",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Unity Control Protocol - CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {