@mflrevan/ucp 0.4.3 → 0.4.5

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

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class ScriptController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("exec/list", HandleList);
+            router.Register("exec/run", HandleRun);
+        }
+
+        private static List<IUCPScript> DiscoverScripts()
+        {
+            var scripts = new List<IUCPScript>();
+            var interfaceType = typeof(IUCPScript);
+
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                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}");
+                            }
+                        }
+                    }
+                }
+                catch (System.Reflection.ReflectionTypeLoadException)
+                {
+                    // Some assemblies can't be scanned - skip silently
+                }
+            }
+
+            return scripts;
+        }
+
+        private static object HandleList(string paramsJson)
+        {
+            var scripts = DiscoverScripts();
+            var result = new List<object>();
+
+            foreach (var s in scripts)
+            {
+                result.Add(new Dictionary<string, object>
+                {
+                    ["name"] = s.Name,
+                    ["description"] = s.Description
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["scripts"] = result,
+                ["count"] = result.Count
+            };
+        }
+
+        private static object HandleRun(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("name", out var nameObj))
+                throw new ArgumentException("Missing 'name' parameter");
+
+            var name = nameObj.ToString();
+            var scriptParams = "{}";
+            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;
+                }
+            }
+
+            if (target == null)
+                throw new ArgumentException($"Script not found: {name}. Use exec/list to see available scripts.");
+
+            var result = target.Execute(scriptParams);
+
+            return new Dictionary<string, object>
+            {
+                ["script"] = name,
+                ["result"] = result
+            };
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 99c09fd6072b27744bc0ca44a4f0f8b8

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

@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    public static class SnapshotController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("snapshot", HandleSnapshot);
+            router.Register("objects/list", HandleListObjects);
+            router.Register("objects/components", HandleGetComponents);
+            router.Register("objects/transform", HandleGetTransform);
+        }
+
+        private static object HandleSnapshot(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var filter = p != null && p.TryGetValue("filter", out var f) ? f?.ToString() : null;
+            var maxDepth = 0;
+            if (p != null && p.TryGetValue("depth", out var d))
+                maxDepth = System.Convert.ToInt32(d);
+
+            var scene = SceneManager.GetActiveScene();
+            var roots = scene.GetRootGameObjects();
+            var objects = new List<object>();
+            int totalObjects = 0;
+            int totalComponents = 0;
+
+            foreach (var root in roots)
+            {
+                SerializeGameObject(root, objects, ref totalObjects, ref totalComponents, filter, 0, maxDepth);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["scene"] = scene.path,
+                ["sceneName"] = scene.name,
+                ["playMode"] = Application.isPlaying,
+                ["timestamp"] = System.DateTime.UtcNow.ToString("o"),
+                ["objects"] = objects,
+                ["stats"] = new Dictionary<string, object>
+                {
+                    ["objectCount"] = totalObjects,
+                    ["componentCount"] = totalComponents,
+                    ["rootCount"] = roots.Length
+                }
+            };
+        }
+
+        private static bool SerializeGameObject(
+            GameObject go, List<object> list, ref int objectCount, ref int componentCount,
+            string filter, int depth, int maxDepth)
+        {
+            bool matchesFilter = string.IsNullOrEmpty(filter)
+                || go.name.Contains(filter, System.StringComparison.OrdinalIgnoreCase);
+
+            var children = new List<object>();
+            if (depth < maxDepth)
+            {
+                for (int i = 0; i < go.transform.childCount; i++)
+                {
+                    SerializeGameObject(
+                        go.transform.GetChild(i).gameObject,
+                        children,
+                        ref objectCount,
+                        ref componentCount,
+                        filter,
+                        depth + 1,
+                        maxDepth);
+                }
+            }
+
+            if (!matchesFilter && children.Count == 0)
+            {
+                return false;
+            }
+
+            objectCount++;
+            var compList = GetComponentTypes(go, ref componentCount);
+
+            var entry = new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetInstanceID(),
+                ["name"] = go.name,
+                ["active"] = go.activeSelf,
+                ["tag"] = go.tag,
+                ["layer"] = go.layer,
+                ["layerName"] = LayerMask.LayerToName(go.layer),
+                ["depth"] = depth,
+                ["childCount"] = go.transform.childCount,
+                ["components"] = compList,
+            };
+
+            if (children.Count > 0)
+                entry["children"] = children;
+
+            list.Add(entry);
+            return true;
+        }
+
+        private static object HandleListObjects(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var maxDepth = 0;
+            if (p != null && p.TryGetValue("depth", out var d))
+                maxDepth = Convert.ToInt32(d);
+
+            var scene = SceneManager.GetActiveScene();
+            var roots = scene.GetRootGameObjects();
+            var objects = new List<object>();
+
+            foreach (var root in roots)
+            {
+                ListObjectsRecursive(root, objects, 0, maxDepth);
+            }
+
+            return new Dictionary<string, object> { ["objects"] = objects };
+        }
+
+        private static void ListObjectsRecursive(GameObject go, List<object> list, int depth, int maxDepth)
+        {
+            list.Add(new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetInstanceID(),
+                ["name"] = go.name,
+                ["active"] = go.activeSelf,
+                ["tag"] = go.tag,
+                ["layer"] = go.layer,
+                ["layerName"] = LayerMask.LayerToName(go.layer),
+                ["childCount"] = go.transform.childCount,
+                ["components"] = GetComponentTypes(go),
+                ["depth"] = depth
+            });
+
+            if (depth < maxDepth)
+            {
+                for (int i = 0; i < go.transform.childCount; i++)
+                    ListObjectsRecursive(go.transform.GetChild(i).gameObject, list, depth + 1, maxDepth);
+            }
+        }
+
+        private static object HandleGetComponents(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("instanceId", out var idObj))
+                throw new System.ArgumentException("Missing 'instanceId' parameter");
+
+            int instanceId = System.Convert.ToInt32(idObj);
+            var go = FindByInstanceId(instanceId);
+            if (go == null)
+                throw new System.Exception($"GameObject not found: {instanceId}");
+
+            var components = go.GetComponents<Component>();
+            var list = new List<object>();
+            foreach (var c in components)
+            {
+                if (c == null) continue;
+                var dict = new Dictionary<string, object>
+                {
+                    ["type"] = c.GetType().Name,
+                    ["fullType"] = c.GetType().FullName
+                };
+                if (c is Behaviour b)
+                    dict["enabled"] = b.enabled;
+                list.Add(dict);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = instanceId,
+                ["name"] = go.name,
+                ["components"] = list
+            };
+        }
+
+        private static object HandleGetTransform(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("instanceId", out var idObj))
+                throw new System.ArgumentException("Missing 'instanceId' parameter");
+
+            int instanceId = System.Convert.ToInt32(idObj);
+            var go = FindByInstanceId(instanceId);
+            if (go == null)
+                throw new System.Exception($"GameObject not found: {instanceId}");
+
+            var t = go.transform;
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = instanceId,
+                ["name"] = go.name,
+                ["position"] = new List<object> { (double)t.position.x, (double)t.position.y, (double)t.position.z },
+                ["localPosition"] = new List<object> { (double)t.localPosition.x, (double)t.localPosition.y, (double)t.localPosition.z },
+                ["rotation"] = new List<object> { (double)t.rotation.x, (double)t.rotation.y, (double)t.rotation.z, (double)t.rotation.w },
+                ["eulerAngles"] = new List<object> { (double)t.eulerAngles.x, (double)t.eulerAngles.y, (double)t.eulerAngles.z },
+                ["localScale"] = new List<object> { (double)t.localScale.x, (double)t.localScale.y, (double)t.localScale.z }
+            };
+        }
+
+        private static GameObject FindByInstanceId(int id)
+        {
+            var obj = UnityEditor.EditorUtility.EntityIdToObject(id);
+            return obj as GameObject;
+        }
+
+        private static List<object> GetComponentTypes(GameObject go)
+        {
+            int ignored = 0;
+            return GetComponentTypes(go, ref ignored);
+        }
+
+        private static List<object> GetComponentTypes(GameObject go, ref int componentCount)
+        {
+            var componentTypes = new List<object>();
+            foreach (var component in go.GetComponents<Component>())
+            {
+                if (component == null) continue;
+                componentCount++;
+                componentTypes.Add(component.GetType().Name);
+            }
+            return componentTypes;
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/SnapshotController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d73a4998b9c64014d8fa833b8a42f2fb

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

@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.TestTools.TestRunner.Api;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class TestRunnerController
+    {
+        private static TestRunnerApi s_api;
+        private static TestResultCollector s_collector;
+
+        public static void Register(CommandRouter router)
+        {
+            router.Register("tests/run", HandleRunTests);
+        }
+
+        private static object HandleRunTests(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var mode = "edit";
+            string filter = null;
+
+            if (p != null)
+            {
+                if (p.TryGetValue("mode", out var m)) mode = m?.ToString() ?? "edit";
+                if (p.TryGetValue("filter", out var f)) filter = f?.ToString();
+            }
+
+            var testMode = mode.ToLowerInvariant() switch
+            {
+                "play" => TestMode.PlayMode,
+                "playmode" => TestMode.PlayMode,
+                _ => TestMode.EditMode
+            };
+
+            if (s_api == null)
+                s_api = ScriptableObject.CreateInstance<TestRunnerApi>();
+
+            if (s_collector != null)
+                s_api.UnregisterCallbacks(s_collector);
+
+            s_collector = new TestResultCollector();
+            s_api.RegisterCallbacks(s_collector);
+
+            var executionSettings = new ExecutionSettings
+            {
+                filters = new[] { new Filter { testMode = testMode } }
+            };
+
+            if (!string.IsNullOrEmpty(filter))
+            {
+                executionSettings.filters[0].testNames = new[] { filter };
+            }
+
+            var shouldWaitForPlayModeExit =
+                testMode == TestMode.EditMode &&
+                (EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode);
+
+            if (shouldWaitForPlayModeExit)
+            {
+                if (EditorApplication.isPlaying)
+                    EditorApplication.isPlaying = false;
+
+                ExecuteWhenReady(executionSettings, testMode, EditorApplication.timeSinceStartup + 30.0);
+            }
+            else
+            {
+                s_api.Execute(executionSettings);
+            }
+
+            // Tests run asynchronously in Unity. We return immediately with a pending status.
+            // Results will be sent as notifications when complete.
+            return new Dictionary<string, object>
+            {
+                ["status"] = "started",
+                ["mode"] = mode,
+                ["message"] = shouldWaitForPlayModeExit
+                    ? "Edit-mode tests queued. Waiting for Unity to exit play mode before starting."
+                    : "Tests started. Results will arrive as notifications."
+            };
+        }
+
+        private static void ExecuteWhenReady(ExecutionSettings settings, TestMode mode, double deadline)
+        {
+            EditorApplication.delayCall += () =>
+            {
+                var stillInPlayMode = EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode;
+                if (mode == TestMode.EditMode && stillInPlayMode)
+                {
+                    if (EditorApplication.timeSinceStartup > deadline)
+                    {
+                        BridgeServer.BroadcastNotification("tests/result", new Dictionary<string, object>
+                        {
+                            ["summary"] = new Dictionary<string, object>
+                            {
+                                ["total"] = 1,
+                                ["passed"] = 0,
+                                ["failed"] = 1,
+                                ["skipped"] = 0,
+                                ["duration"] = 0.0
+                            },
+                            ["tests"] = new List<object>
+                            {
+                                new Dictionary<string, object>
+                                {
+                                    ["name"] = "UCP.Bridge.Tests.PlayModeExitGuard",
+                                    ["status"] = "failed",
+                                    ["duration"] = 0.0,
+                                    ["message"] = "Timed out waiting for Unity to exit play mode before running edit-mode tests."
+                                }
+                            }
+                        });
+
+                        if (s_api != null && s_collector != null)
+                            s_api.UnregisterCallbacks(s_collector);
+                        return;
+                    }
+
+                    ExecuteWhenReady(settings, mode, deadline);
+                    return;
+                }
+
+                s_api.Execute(settings);
+            };
+        }
+
+        private class TestResultCollector : ICallbacks
+        {
+            private readonly List<object> _results = new();
+            private int _passed, _failed, _skipped;
+            private double _startTime;
+
+            public TestResultCollector()
+            {
+                _startTime = EditorApplication.timeSinceStartup;
+            }
+
+            public void RunStarted(ITestAdaptor testsToRun) { }
+
+            public void RunFinished(ITestResultAdaptor result)
+            {
+                _results.Clear();
+                _passed = 0;
+                _failed = 0;
+                _skipped = 0;
+                CollectLeafResults(result);
+
+                var duration = EditorApplication.timeSinceStartup - _startTime;
+
+                var summary = new Dictionary<string, object>
+                {
+                    ["total"] = _passed + _failed + _skipped,
+                    ["passed"] = _passed,
+                    ["failed"] = _failed,
+                    ["skipped"] = _skipped,
+                    ["duration"] = (double)duration
+                };
+
+                BridgeServer.BroadcastNotification("tests/result", new Dictionary<string, object>
+                {
+                    ["summary"] = summary,
+                    ["tests"] = _results
+                });
+
+                if (s_api != null)
+                    s_api.UnregisterCallbacks(this);
+            }
+
+            public void TestStarted(ITestAdaptor test) { }
+
+            public void TestFinished(ITestResultAdaptor result) { }
+
+            private void CollectLeafResults(ITestResultAdaptor result)
+            {
+                if (result == null)
+                    return;
+
+                if (result.HasChildren)
+                {
+                    foreach (var child in result.Children)
+                        CollectLeafResults(child);
+                    return;
+                }
+
+                string status;
+                switch (result.TestStatus)
+                {
+                    case TestStatus.Passed:
+                        status = "passed";
+                        _passed++;
+                        break;
+                    case TestStatus.Failed:
+                        status = "failed";
+                        _failed++;
+                        break;
+                    case TestStatus.Skipped:
+                        status = "skipped";
+                        _skipped++;
+                        break;
+                    default:
+                        status = "unknown";
+                        break;
+                }
+
+                var entry = new Dictionary<string, object>
+                {
+                    ["name"] = ResolveTestName(result),
+                    ["status"] = status,
+                    ["duration"] = result.Duration
+                };
+
+                if (!string.IsNullOrEmpty(result.Message))
+                    entry["message"] = result.Message;
+                if (!string.IsNullOrEmpty(result.StackTrace))
+                    entry["stackTrace"] = result.StackTrace;
+
+                _results.Add(entry);
+            }
+
+            private static string ResolveTestName(ITestResultAdaptor result)
+            {
+                if (!string.IsNullOrEmpty(result.FullName))
+                    return result.FullName;
+
+                if (result.Test != null)
+                {
+                    if (!string.IsNullOrEmpty(result.Test.FullName))
+                        return result.Test.FullName;
+                    if (!string.IsNullOrEmpty(result.Test.Name))
+                        return result.Test.Name;
+                }
+
+                return result.Name;
+            }
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/TestRunnerController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6cb4d794571ded244bda9bb540e7c25f