@mflrevan/ucp 0.6.0 → 0.6.1

package/bridge/com.ucp.bridge/Editor/Protocol/MiniJson.cs

@@ -28,7 +28,13 @@ namespace UCP.Bridge
 
         private sealed class Parser : IDisposable
         {
+            /// Guards against stack overflow on deeply nested input. A stack overflow is not
+            /// catchable in .NET and kills the editor process outright, so the parser trades
+            /// pathological depth for a normal, catchable exception.
+            private const int MaxParseDepth = 256;
+
             private StringReader _reader;
+            private int _depth;
 
             private Parser(string jsonString)
             {
@@ -78,16 +84,24 @@ namespace UCP.Bridge
                 ReadChar(); // {
                 var dict = new Dictionary<string, object>();
 
-                while (true)
+                EnterContainer();
+                try
                 {
-                    EatWhitespace();
-                    if (PeekChar() == '}') { ReadChar(); return dict; }
-                    if (PeekChar() == ',') { ReadChar(); continue; }
-
-                    var key = ParseString();
-                    EatWhitespace();
-                    ReadChar(); // :
-                    dict[key] = ParseValue();
+                    while (true)
+                    {
+                        EatWhitespace();
+                        if (PeekChar() == '}') { ReadChar(); return dict; }
+                        if (PeekChar() == ',') { ReadChar(); continue; }
+
+                        var key = ParseString();
+                        EatWhitespace();
+                        ReadChar(); // :
+                        dict[key] = ParseValue();
+                    }
+                }
+                finally
+                {
+                    _depth--;
                 }
             }
 
@@ -96,16 +110,31 @@ namespace UCP.Bridge
                 ReadChar(); // [
                 var list = new List<object>();
 
-                while (true)
+                EnterContainer();
+                try
                 {
-                    EatWhitespace();
-                    if (PeekChar() == ']') { ReadChar(); return list; }
-                    if (PeekChar() == ',') { ReadChar(); continue; }
+                    while (true)
+                    {
+                        EatWhitespace();
+                        if (PeekChar() == ']') { ReadChar(); return list; }
+                        if (PeekChar() == ',') { ReadChar(); continue; }
 
-                    list.Add(ParseValue());
+                        list.Add(ParseValue());
+                    }
+                }
+                finally
+                {
+                    _depth--;
                 }
             }
 
+            private void EnterContainer()
+            {
+                if (_depth >= MaxParseDepth)
+                    throw new FormatException($"JSON nesting exceeds {MaxParseDepth} levels");
+                _depth++;
+            }
+
             private string ParseString()
             {
                 ReadChar(); // opening "
@@ -200,16 +229,45 @@ namespace UCP.Bridge
                 return c < 0 ? '\0' : (char)c;
             }
 
+            /// Truncated input used to yield '\0' forever, which spun ParseString in an infinite
+            /// loop and hung the editor's main thread. Fail loudly at end-of-input instead.
             private char ReadChar()
             {
                 int c = _reader.Read();
-                return c < 0 ? '\0' : (char)c;
+                if (c < 0) throw new FormatException("Unexpected end of JSON input");
+                return (char)c;
             }
         }
 
         private sealed class Serializer
         {
+            /// <summary>
+            /// Reflection is the dangerous path: computed properties can hand back fresh instances
+            /// of their own type forever (UnityEngine.Vector3.normalized is the canonical example),
+            /// so an unbounded walk stack-overflows -- which is not catchable in .NET and takes the
+            /// whole editor process down with it. Bound it.
+            /// </summary>
+            private const int MaxReflectionDepth = 8;
+
+            /// Backstop for container nesting (dictionaries/lists). Reference cycles are caught
+            /// separately, so this only fires on genuinely pathological payloads.
+            private const int MaxDepth = 96;
+
+            /// Total reflected objects per payload, to bound fan-out: a type whose properties each
+            /// return new instances of a similar type grows exponentially, not linearly, with depth.
+            private const int MaxReflectedObjects = 20000;
+
+            private const string MaxDepthMarker = "<ucp:max-depth>";
+            private const string CycleMarker = "<ucp:cycle>";
+            private const string TruncatedMarker = "<ucp:truncated>";
+
+            private static readonly CultureInfo Inv = CultureInfo.InvariantCulture;
+
             private readonly StringBuilder _sb = new();
+            private readonly HashSet<object> _visited = new(ReferenceComparer.Instance);
+            private int _depth;
+            private int _reflectionDepth;
+            private int _reflectedObjects;
 
             public static string Serialize(object obj)
             {
@@ -224,43 +282,270 @@ namespace UCP.Bridge
                 {
                     case null:
                         _sb.Append("null");
-                        break;
+                        return;
                     case string s:
                         WriteString(s);
-                        break;
+                        return;
                     case bool b:
                         _sb.Append(b ? "true" : "false");
-                        break;
-                    case IDictionary dict:
-                        WriteDict(dict);
-                        break;
-                    case IList list:
-                        WriteArray(list);
-                        break;
+                        return;
                     case float f:
-                        _sb.Append(f.ToString("R", CultureInfo.InvariantCulture));
-                        break;
+                        WriteFloat(f);
+                        return;
                     case double d:
-                        _sb.Append(d.ToString("R", CultureInfo.InvariantCulture));
-                        break;
-                    case int i:
-                        _sb.Append(i);
-                        break;
-                    case long l:
-                        _sb.Append(l);
-                        break;
+                        WriteDouble(d);
+                        return;
+                    case decimal m:
+                        _sb.Append(m.ToString(Inv));
+                        return;
                     case Enum e:
-                        _sb.Append(Convert.ToInt32(e));
-                        break;
+                        WriteEnum(e);
+                        return;
+                    case byte v:
+                        _sb.Append(((int)v).ToString(Inv));
+                        return;
+                    case sbyte v:
+                        _sb.Append(((int)v).ToString(Inv));
+                        return;
+                    case short v:
+                        _sb.Append(((int)v).ToString(Inv));
+                        return;
+                    case ushort v:
+                        _sb.Append(((int)v).ToString(Inv));
+                        return;
+                    case int v:
+                        _sb.Append(v.ToString(Inv));
+                        return;
+                    case uint v:
+                        _sb.Append(v.ToString(Inv));
+                        return;
+                    case long v:
+                        _sb.Append(v.ToString(Inv));
+                        return;
+                    case ulong v:
+                        _sb.Append(v.ToString(Inv));
+                        return;
+                    case char c:
+                        WriteString(c.ToString());
+                        return;
+                    case DateTime dt:
+                        WriteString(dt.ToString("o", Inv));
+                        return;
+                    case DateTimeOffset dto:
+                        WriteString(dto.ToString("o", Inv));
+                        return;
+                    case TimeSpan ts:
+                        WriteString(ts.ToString(null, Inv));
+                        return;
+                    case Guid g:
+                        WriteString(g.ToString());
+                        return;
+                    case Type t:
+                        WriteString(t.FullName);
+                        return;
+                }
+
+                // Unity's math structs expose self-referential computed properties
+                // (Vector3.normalized, Quaternion.normalized, Bounds.extents, ...) plus indexers.
+                // Reflecting over them is what crashed the editor, so give them explicit shapes.
+                if (TryWriteUnityValue(obj)) return;
+
+                // UnityEngine.Object graphs are cyclic by construction
+                // (GameObject.transform.gameObject), reach the entire scene, and carry no useful
+                // JSON projection. Emit an identity instead of walking them.
+                if (obj is UnityEngine.Object uo)
+                {
+                    WriteUnityObject(uo);
+                    return;
+                }
+
+                // Everything below here recurses, so it needs the depth and cycle guards.
+                if (_depth >= MaxDepth)
+                {
+                    WriteString(MaxDepthMarker);
+                    return;
+                }
+
+                var track = !obj.GetType().IsValueType;
+                if (track && !_visited.Add(obj))
+                {
+                    WriteString(CycleMarker);
+                    return;
+                }
+
+                _depth++;
+                try
+                {
+                    switch (obj)
+                    {
+                        case IDictionary dict:
+                            WriteDict(dict);
+                            break;
+                        case IList list:
+                            WriteArray(list);
+                            break;
+                        case IEnumerable seq:
+                            WriteEnumerable(seq);
+                            break;
+                        default:
+                            WriteObject(obj);
+                            break;
+                    }
+                }
+                finally
+                {
+                    _depth--;
+                    if (track) _visited.Remove(obj);
+                }
+            }
+
+            private void WriteEnum(Enum e)
+            {
+                try
+                {
+                    if (Enum.GetUnderlyingType(e.GetType()) == typeof(ulong))
+                        _sb.Append(Convert.ToUInt64(e).ToString(Inv));
+                    else
+                        _sb.Append(Convert.ToInt64(e).ToString(Inv));
+                }
+                catch
+                {
+                    WriteString(e.ToString());
+                }
+            }
+
+            /// NaN and Infinity are not valid JSON; emitting them raw yields a payload the CLI
+            /// cannot parse. Unity produces them routinely (degenerate bounds, zero-length
+            /// normalize, uninitialized transforms).
+            private void WriteFloat(float f)
+            {
+                if (float.IsNaN(f) || float.IsInfinity(f)) _sb.Append("null");
+                else _sb.Append(f.ToString("R", Inv));
+            }
+
+            private void WriteDouble(double d)
+            {
+                if (double.IsNaN(d) || double.IsInfinity(d)) _sb.Append("null");
+                else _sb.Append(d.ToString("R", Inv));
+            }
+
+            private bool TryWriteUnityValue(object obj)
+            {
+                switch (obj)
+                {
+                    case UnityEngine.Vector2 v:
+                        WriteFloats(("x", v.x), ("y", v.y));
+                        return true;
+                    case UnityEngine.Vector3 v:
+                        WriteFloats(("x", v.x), ("y", v.y), ("z", v.z));
+                        return true;
+                    case UnityEngine.Vector4 v:
+                        WriteFloats(("x", v.x), ("y", v.y), ("z", v.z), ("w", v.w));
+                        return true;
+                    case UnityEngine.Quaternion q:
+                        WriteFloats(("x", q.x), ("y", q.y), ("z", q.z), ("w", q.w));
+                        return true;
+                    case UnityEngine.Color c:
+                        WriteFloats(("r", c.r), ("g", c.g), ("b", c.b), ("a", c.a));
+                        return true;
+                    case UnityEngine.Color32 c:
+                        WriteFloats(("r", c.r), ("g", c.g), ("b", c.b), ("a", c.a));
+                        return true;
+                    case UnityEngine.Vector2Int v:
+                        WriteFloats(("x", v.x), ("y", v.y));
+                        return true;
+                    case UnityEngine.Vector3Int v:
+                        WriteFloats(("x", v.x), ("y", v.y), ("z", v.z));
+                        return true;
+                    case UnityEngine.Rect r:
+                        WriteFloats(("x", r.x), ("y", r.y), ("width", r.width), ("height", r.height));
+                        return true;
+                    case UnityEngine.RectInt r:
+                        WriteFloats(("x", r.x), ("y", r.y), ("width", r.width), ("height", r.height));
+                        return true;
+                    case UnityEngine.Bounds b:
+                        WriteBounds(b.center, b.size);
+                        return true;
+                    case UnityEngine.BoundsInt b:
+                        WriteBounds(b.center, b.size);
+                        return true;
+                    case UnityEngine.Matrix4x4 mtx:
+                        _sb.Append('[');
+                        for (int i = 0; i < 16; i++)
+                        {
+                            if (i > 0) _sb.Append(',');
+                            WriteFloat(mtx[i]);
+                        }
+                        _sb.Append(']');
+                        return true;
                     default:
-                        // For anonymous types and other objects, use reflection
-                        WriteObject(obj);
-                        break;
+                        return false;
+                }
+            }
+
+            private void WriteFloats(params (string Name, float Value)[] members)
+            {
+                _sb.Append('{');
+                for (int i = 0; i < members.Length; i++)
+                {
+                    if (i > 0) _sb.Append(',');
+                    WriteString(members[i].Name);
+                    _sb.Append(':');
+                    WriteFloat(members[i].Value);
+                }
+                _sb.Append('}');
+            }
+
+            private void WriteBounds(UnityEngine.Vector3 center, UnityEngine.Vector3 size)
+            {
+                _sb.Append("{\"center\":");
+                WriteFloats(("x", center.x), ("y", center.y), ("z", center.z));
+                _sb.Append(",\"size\":");
+                WriteFloats(("x", size.x), ("y", size.y), ("z", size.z));
+                _sb.Append('}');
+            }
+
+            private void WriteUnityObject(UnityEngine.Object uo)
+            {
+                // Unity's overloaded == reports destroyed objects as null even though the managed
+                // reference is alive, and touching .name on those throws.
+                if (uo == null)
+                {
+                    _sb.Append("null");
+                    return;
+                }
+
+                string name;
+                int id;
+                try
+                {
+                    name = uo.name;
+                    id = uo.GetId();
                 }
+                catch
+                {
+                    _sb.Append("null");
+                    return;
+                }
+
+                _sb.Append('{');
+                WriteString("name");
+                _sb.Append(':');
+                WriteString(name);
+                _sb.Append(",\"instanceId\":");
+                _sb.Append(id.ToString(Inv));
+                _sb.Append(",\"type\":");
+                WriteString(uo.GetType().Name);
+                _sb.Append('}');
             }
 
             private void WriteString(string s)
             {
+                if (s == null)
+                {
+                    _sb.Append("null");
+                    return;
+                }
                 _sb.Append('"');
                 foreach (var c in s)
                 {
@@ -292,7 +577,8 @@ namespace UCP.Bridge
                 {
                     if (!first) _sb.Append(',');
                     first = false;
-                    WriteString(entry.Key.ToString());
+                    // A key must always be a quoted string, even if ToString() yields null.
+                    WriteString(entry.Key?.ToString() ?? string.Empty);
                     _sb.Append(':');
                     WriteValue(entry.Value);
                 }
@@ -310,7 +596,45 @@ namespace UCP.Bridge
                 _sb.Append(']');
             }
 
+            private void WriteEnumerable(IEnumerable seq)
+            {
+                _sb.Append('[');
+                bool first = true;
+                foreach (var item in seq)
+                {
+                    if (!first) _sb.Append(',');
+                    first = false;
+                    WriteValue(item);
+                }
+                _sb.Append(']');
+            }
+
             private void WriteObject(object obj)
+            {
+                if (_reflectionDepth >= MaxReflectionDepth)
+                {
+                    WriteString(MaxDepthMarker);
+                    return;
+                }
+                if (_reflectedObjects >= MaxReflectedObjects)
+                {
+                    WriteString(TruncatedMarker);
+                    return;
+                }
+
+                _reflectedObjects++;
+                _reflectionDepth++;
+                try
+                {
+                    WriteObjectMembers(obj);
+                }
+                finally
+                {
+                    _reflectionDepth--;
+                }
+            }
+
+            private void WriteObjectMembers(object obj)
             {
                 var type = obj.GetType();
                 var props = type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
@@ -322,37 +646,59 @@ namespace UCP.Bridge
                 foreach (var prop in props)
                 {
                     if (!prop.CanRead) continue;
-                    try
-                    {
-                        var val = prop.GetValue(obj);
-                        if (!first) _sb.Append(',');
-                        first = false;
-                        // Convert PascalCase to camelCase
-                        var name = char.ToLowerInvariant(prop.Name[0]) + prop.Name.Substring(1);
-                        WriteString(name);
-                        _sb.Append(':');
-                        WriteValue(val);
-                    }
-                    catch { }
+                    // Indexers (Vector3's this[int], IList's this[int], ...) have no readable value.
+                    if (prop.GetIndexParameters().Length > 0) continue;
+                    var captured = prop;
+                    WriteMember(captured.Name, () => captured.GetValue(obj), ref first);
                 }
 
                 foreach (var field in fields)
                 {
-                    try
-                    {
-                        var val = field.GetValue(obj);
-                        if (!first) _sb.Append(',');
-                        first = false;
-                        var name = char.ToLowerInvariant(field.Name[0]) + field.Name.Substring(1);
-                        WriteString(name);
-                        _sb.Append(':');
-                        WriteValue(val);
-                    }
-                    catch { }
+                    var captured = field;
+                    WriteMember(captured.Name, () => captured.GetValue(obj), ref first);
                 }
 
                 _sb.Append('}');
             }
+
+            /// Writes one member, rolling the buffer back if reading or serializing it throws.
+            /// The separator and key used to be appended before the value was evaluated, so a
+            /// throwing getter left a dangling `"key":` behind and produced invalid JSON.
+            private void WriteMember(string name, Func<object> read, ref bool first)
+            {
+                var rollback = _sb.Length;
+                var wasFirst = first;
+                try
+                {
+                    var val = read();
+                    if (!first) _sb.Append(',');
+                    first = false;
+                    // Convert PascalCase to camelCase
+                    WriteString(string.IsNullOrEmpty(name)
+                        ? name
+                        : char.ToLowerInvariant(name[0]) + name.Substring(1));
+                    _sb.Append(':');
+                    WriteValue(val);
+                }
+                catch
+                {
+                    _sb.Length = rollback;
+                    first = wasFirst;
+                }
+            }
+
+            /// Identity comparer for cycle detection: value equality would collapse distinct but
+            /// equal nodes, and a payload type's own Equals/GetHashCode can be arbitrarily
+            /// expensive or throw.
+            private sealed class ReferenceComparer : IEqualityComparer<object>
+            {
+                public static readonly ReferenceComparer Instance = new();
+
+                public new bool Equals(object x, object y) => ReferenceEquals(x, y);
+
+                public int GetHashCode(object obj) =>
+                    System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+            }
         }
     }
 }

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

@@ -307,10 +307,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 +1180,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));
         }