@mflrevan/ucp 0.5.1 → 0.6.0

package/README.md

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

package/bridge/com.ucp.bridge/Editor/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("UCP.Bridge.Editor.Tests")]

package/bridge/com.ucp.bridge/Editor/AssemblyInfo.cs.meta

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

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.5.1";
+        private const string ProtocolVersion = "0.6.0";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -72,11 +72,12 @@ namespace UCP.Bridge
             try
             {
                 RegisterHandlers();
+                LogsController.SeedHistoryFromConsole();
 
                 EditorApplication.update += PumpMainThread;
                 EditorApplication.quitting += Shutdown;
                 AssemblyReloadEvents.beforeAssemblyReload += Shutdown;
-                Application.logMessageReceived += OnLogMessage;
+                Application.logMessageReceivedThreaded += OnLogMessage;
 
                 s_token = Guid.NewGuid().ToString("N").Substring(0, 16);
                 StartServer();
@@ -144,6 +145,15 @@ namespace UCP.Bridge
             // Hierarchy Operations
             HierarchyController.Register(s_router);
 
+            // Transform authoring (move/rotate/scale/look-at, bulk read)
+            TransformController.Register(s_router);
+
+            // Spatial queries (raycast/overlap/bounds/ground/nearest)
+            SpatialController.Register(s_router);
+
+            // Composed visual perception (capture/isolate/orbit)
+            ViewController.Register(s_router);
+
             // Asset Management
             AssetController.Register(s_router);
             ImporterController.Register(s_router);
@@ -165,6 +175,9 @@ namespace UCP.Bridge
 
             // Reference search (bridge fallback)
             ReferenceController.Register(s_router);
+
+            // Shader diagnostics
+            ShaderController.Register(s_router);
         }
 
         private static void StartServer()
@@ -555,7 +568,7 @@ namespace UCP.Bridge
             CleanLockFile();
 
             EditorApplication.update -= PumpMainThread;
-            Application.logMessageReceived -= OnLogMessage;
+            Application.logMessageReceivedThreaded -= OnLogMessage;
         }
 
         private static Dictionary<string, object> ResponseToDict(JsonRpcResponse r)

package/bridge/com.ucp.bridge/Editor/Compatibility/UnityObjectCompat.cs

@@ -1,13 +1,39 @@
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.SceneManagement;
 
 namespace UCP.Bridge
 {
     internal static class UnityObjectCompat
     {
+        public static int GetId(this Object obj)
+        {
+#if UNITY_6000_5_OR_NEWER
+            return unchecked((int)EntityId.ToULong(obj.GetEntityId()));
+#else
+            return obj.GetInstanceID();
+#endif
+        }
+
+        public static long GetSceneHandle(Scene scene)
+        {
+#if UNITY_6000_5_OR_NEWER
+            return unchecked((long)scene.handle.GetRawData());
+#else
+            // On 6000.0–6000.4, Scene.handle is a SceneHandle with implicit int and
+            // uint operators; widening straight to long is ambiguous (CS0457). Pin the
+            // int conversion explicitly — handles are 32-bit on these versions.
+            return (int)scene.handle;
+#endif
+        }
+
         public static Object ResolveByInstanceId(int instanceId)
         {
+#if UNITY_6000_5_OR_NEWER
+            return EditorUtility.EntityIdToObject(EntityId.FromULong(unchecked((ulong)instanceId)));
+#else
             return EditorUtility.InstanceIDToObject(instanceId);
+#endif
         }
 
         public static T ResolveByInstanceId<T>(int instanceId) where T : Object

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

@@ -5,6 +5,7 @@ using System.Reflection;
 using System.Text.RegularExpressions;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Rendering;
 
 namespace UCP.Bridge
 {
@@ -14,6 +15,7 @@ namespace UCP.Bridge
         {
             router.Register("asset/search", HandleSearch);
             router.Register("asset/info", HandleInfo);
+            router.Register("asset/inspect", HandleInspect);
             router.Register("asset/read", HandleReadScriptableObject);
             router.Register("asset/write", HandleWriteScriptableObject);
             router.Register("asset/write-batch", HandleWriteScriptableObjectBatch);
@@ -123,7 +125,7 @@ namespace UCP.Bridge
                 ["name"] = asset.name,
                 ["type"] = asset.GetType().Name,
                 ["fullType"] = asset.GetType().FullName,
-                ["instanceId"] = asset.GetInstanceID(),
+                ["instanceId"] = asset.GetId(),
                 ["guid"] = AssetDatabase.AssetPathToGUID(assetPath)
             };
 
@@ -152,6 +154,47 @@ namespace UCP.Bridge
             return info;
         }
 
+        private static object HandleInspect(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("path", out var pathObj))
+                throw new ArgumentException("Missing 'path' parameter");
+
+            string assetPath = pathObj.ToString();
+            int maxFields = 80;
+            if (p.TryGetValue("maxFields", out var maxObj) && maxObj != null)
+                maxFields = Math.Max(1, Convert.ToInt32(maxObj));
+
+            var asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+            if (asset == null)
+                throw new ArgumentException($"Asset not found: {assetPath}");
+
+            var result = HandleInfo(paramsJson) as Dictionary<string, object>;
+            result["inspectedAtUtc"] = DateTime.UtcNow.ToString("o");
+
+            var importer = AssetImporter.GetAtPath(assetPath);
+            if (importer != null)
+                result["importer"] = InspectSerializedObject(importer, maxFields);
+
+            if (asset is Material material)
+            {
+                result["shader"] = material.shader != null ? material.shader.name : string.Empty;
+                result["shaderPath"] = material.shader != null ? AssetDatabase.GetAssetPath(material.shader) : string.Empty;
+                result["keywords"] = InspectMaterialKeywords(material);
+                result["properties"] = InspectMaterialProperties(material, maxFields);
+            }
+            else if (asset is GameObject gameObject)
+            {
+                result["renderers"] = InspectPrefabRenderers(gameObject);
+            }
+            else
+            {
+                result["fields"] = InspectSerializedObject(asset, maxFields);
+            }
+
+            return result;
+        }
+
         private static object HandleReadScriptableObject(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -211,6 +254,133 @@ namespace UCP.Bridge
             };
         }
 
+        private static List<object> InspectSerializedObject(UnityEngine.Object target, int maxFields)
+        {
+            var serializedObject = new SerializedObject(target);
+            var fields = new List<object>();
+            try
+            {
+                var iterator = serializedObject.GetIterator();
+                if (iterator.NextVisible(true))
+                {
+                    do
+                    {
+                        if (iterator.name == "m_Script") continue;
+                        fields.Add(SerializedPropertyControllerSupport.Describe(iterator));
+                    }
+                    while (fields.Count < maxFields && iterator.NextVisible(false));
+                }
+            }
+            finally
+            {
+                serializedObject.Dispose();
+            }
+
+            return fields;
+        }
+
+        private static List<object> InspectMaterialKeywords(Material material)
+        {
+            var keywords = new List<object>();
+            foreach (var keyword in material.enabledKeywords)
+                keywords.Add(keyword.name);
+            return keywords;
+        }
+
+        private static List<object> InspectMaterialProperties(Material material, int maxFields)
+        {
+            var properties = new List<object>();
+            var shader = material.shader;
+            if (shader == null)
+                return properties;
+
+            var count = Math.Min(shader.GetPropertyCount(), maxFields);
+            for (int i = 0; i < count; i++)
+            {
+                var name = shader.GetPropertyName(i);
+                var type = shader.GetPropertyType(i);
+                properties.Add(new Dictionary<string, object>
+                {
+                    ["name"] = name,
+                    ["description"] = shader.GetPropertyDescription(i),
+                    ["type"] = type.ToString(),
+                    ["value"] = ReadMaterialValue(material, name, type)
+                });
+            }
+
+            return properties;
+        }
+
+        private static object ReadMaterialValue(Material material, string name, ShaderPropertyType type)
+        {
+            switch (type)
+            {
+                case ShaderPropertyType.Color:
+                    var color = material.GetColor(name);
+                    return new List<object> { color.r, color.g, color.b, color.a };
+                case ShaderPropertyType.Vector:
+                    var vector = material.GetVector(name);
+                    return new List<object> { vector.x, vector.y, vector.z, vector.w };
+                case ShaderPropertyType.Float:
+                case ShaderPropertyType.Range:
+                    return material.GetFloat(name);
+                case ShaderPropertyType.Texture:
+                    var texture = material.GetTexture(name);
+                    return texture != null
+                        ? new Dictionary<string, object>
+                        {
+                            ["name"] = texture.name,
+                            ["path"] = AssetDatabase.GetAssetPath(texture),
+                            ["type"] = texture.GetType().Name
+                        }
+                        : null;
+                default:
+                    return null;
+            }
+        }
+
+        private static List<object> InspectPrefabRenderers(GameObject gameObject)
+        {
+            var renderers = new List<object>();
+            foreach (var renderer in gameObject.GetComponentsInChildren<Renderer>(true))
+            {
+                var materials = new List<object>();
+                foreach (var material in renderer.sharedMaterials)
+                {
+                    materials.Add(material != null
+                        ? new Dictionary<string, object>
+                        {
+                            ["name"] = material.name,
+                            ["path"] = AssetDatabase.GetAssetPath(material),
+                            ["shader"] = material.shader != null ? material.shader.name : string.Empty
+                        }
+                        : null);
+                }
+
+                renderers.Add(new Dictionary<string, object>
+                {
+                    ["path"] = GetTransformPath(renderer.transform),
+                    ["type"] = renderer.GetType().Name,
+                    ["enabled"] = renderer.enabled,
+                    ["materials"] = materials
+                });
+            }
+
+            return renderers;
+        }
+
+        private static string GetTransformPath(Transform transform)
+        {
+            var names = new List<string>();
+            var current = transform;
+            while (current != null)
+            {
+                names.Insert(0, current.name);
+                current = current.parent;
+            }
+            return string.Join("/", names);
+        }
+
         private static object HandleWriteScriptableObject(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -326,7 +496,7 @@ namespace UCP.Bridge
                 ["status"] = "ok",
                 ["path"] = assetPath,
                 ["type"] = soType.Name,
-                ["instanceId"] = instance.GetInstanceID()
+                ["instanceId"] = instance.GetId()
             };
         }
 

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

@@ -1,5 +1,9 @@
 using UnityEditor;
 using UnityEditor.Compilation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
 
 namespace UCP.Bridge
 {
@@ -9,12 +13,15 @@ namespace UCP.Bridge
         {
             router.Register("compile", HandleCompile);
             router.Register("refresh-assets", HandleRefresh);
+            router.Register("script/doctor", HandleScriptDoctor);
         }
 
         private static object HandleCompile(string paramsJson)
         {
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             CompilationPipeline.RequestScriptCompilation();
-            return new { status = "ok", message = "Compilation requested" };
+            TrySyncSolution();
+            return new { status = "ok", message = "Asset database refreshed and compilation requested" };
         }
 
         private static object HandleRefresh(string paramsJson)
@@ -22,5 +29,85 @@ namespace UCP.Bridge
             AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             return new { status = "ok", message = "Asset database refreshed" };
         }
+
+        private static object HandleScriptDoctor(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var fix = p != null && p.TryGetValue("fix", out var fixObj) && fixObj != null && Convert.ToBoolean(fixObj);
+            var projectRoot = Directory.GetParent(UnityEngine.Application.dataPath).FullName;
+            var projects = new List<object>();
+            var staleProjectCount = 0;
+            var missingFileCount = 0;
+            var deletedProjectCount = 0;
+
+            foreach (var csproj in Directory.GetFiles(projectRoot, "*.csproj", SearchOption.TopDirectoryOnly))
+            {
+                var missing = FindMissingCompileItems(projectRoot, csproj);
+                if (missing.Count > 0)
+                {
+                    staleProjectCount++;
+                    missingFileCount += missing.Count;
+                    if (fix)
+                    {
+                        File.Delete(csproj);
+                        deletedProjectCount++;
+                    }
+                }
+
+                projects.Add(new Dictionary<string, object>
+                {
+                    ["path"] = csproj,
+                    ["missingCompileItems"] = missing.ConvertAll<object>(item => item),
+                    ["stale"] = missing.Count > 0
+                });
+            }
+
+            if (fix)
+            {
+                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+                TrySyncSolution();
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["projectRoot"] = projectRoot,
+                ["projectCount"] = projects.Count,
+                ["staleProjectCount"] = staleProjectCount,
+                ["missingFileCount"] = missingFileCount,
+                ["deletedProjectCount"] = deletedProjectCount,
+                ["fixed"] = fix,
+                ["projects"] = projects
+            };
+        }
+
+        private static List<string> FindMissingCompileItems(string projectRoot, string csproj)
+        {
+            var missing = new List<string>();
+            var content = File.ReadAllText(csproj);
+            foreach (Match match in Regex.Matches(content, "<Compile Include=\"([^\"]+\\.cs)\""))
+            {
+                var include = match.Groups[1].Value.Replace('\\', Path.DirectorySeparatorChar);
+                var fullPath = Path.GetFullPath(Path.Combine(projectRoot, include));
+                if (!File.Exists(fullPath))
+                    missing.Add(include.Replace('\\', '/'));
+            }
+
+            return missing;
+        }
+
+        private static void TrySyncSolution()
+        {
+            try
+            {
+                var syncVs = typeof(Editor).Assembly.GetType("UnityEditor.SyncVS");
+                var method = syncVs?.GetMethod("SyncSolution", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic, null, Type.EmptyTypes, null);
+                method?.Invoke(null, null);
+            }
+            catch
+            {
+                // Best-effort only; Unity may regenerate solution files asynchronously.
+            }
+        }
     }
 }

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

@@ -0,0 +1,60 @@
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Centralizes editor operations that must stay non-blocking when the bridge drives
+    /// the editor headlessly.
+    ///
+    /// Bridge commands run on the main thread via EditorApplication.update. Any modal
+    /// dialog (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo,
+    /// EditorUtility.DisplayDialog, file/folder panels, ...) blocks that loop with no user
+    /// present to dismiss it, hanging every queued command and timing out the CLI. Bridge
+    /// code must therefore never call a modal API. Scene saving is the most common trap, so
+    /// it lives here behind a single audited, modal-free implementation shared by every
+    /// controller instead of being copy-pasted per controller.
+    /// </summary>
+    internal static class EditorModalGuard
+    {
+        /// <summary>
+        /// Saves every loaded dirty scene without prompting. Dirty untitled scenes have no
+        /// path to save to; they are discarded (replaced with a fresh empty scene) when
+        /// <paramref name="discardUntitled"/> is true, otherwise an exception is thrown so
+        /// the caller surfaces a clear error instead of silently losing work or blocking on
+        /// a save dialog.
+        /// </summary>
+        public static void SaveOpenDirtyScenes(bool saveDirtyScenes, bool discardUntitled)
+        {
+            if (!saveDirtyScenes)
+                return;
+
+            var requiresUntitledDiscard = false;
+
+            for (var index = 0; index < SceneManager.sceneCount; index++)
+            {
+                var scene = SceneManager.GetSceneAt(index);
+                if (!scene.isLoaded || !scene.isDirty)
+                    continue;
+
+                if (string.IsNullOrEmpty(scene.path))
+                {
+                    if (!discardUntitled)
+                        throw new System.InvalidOperationException("Dirty untitled scene cannot be auto-saved. Retry with discardUntitled=true.");
+
+                    requiresUntitledDiscard = true;
+                    continue;
+                }
+
+                if (!EditorSceneManager.SaveScene(scene))
+                    throw new System.InvalidOperationException($"Failed to auto-save dirty scene: {scene.path}");
+
+                SceneChangeTracker.ClearScene(scene);
+            }
+
+            if (requiresUntitledDiscard)
+                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+        }
+    }
+}

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

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

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

@@ -26,7 +26,19 @@ namespace UCP.Bridge
             if (p != null && p.TryGetValue("name", out var nameObj) && nameObj != null)
                 name = nameObj.ToString();
 
-            var go = new GameObject(name);
+            // Optional primitive: build a Cube/Sphere/etc. with mesh + collider in one step.
+            // Without this an agent has to hand-assemble MeshFilter + MeshRenderer and somehow
+            // reference the built-in mesh, which is not practical over the CLI.
+            GameObject go;
+            if (p != null && p.TryGetValue("primitive", out var primObj) && primObj != null)
+            {
+                go = GameObject.CreatePrimitive(ParsePrimitive(primObj.ToString()));
+                go.name = name;
+            }
+            else
+            {
+                go = new GameObject(name);
+            }
             Undo.RegisterCreatedObjectUndo(go, "UCP Create GameObject");
 
             // Optional parent
@@ -61,7 +73,7 @@ namespace UCP.Bridge
             return new Dictionary<string, object>
             {
                 ["status"] = "ok",
-                ["instanceId"] = go.GetInstanceID(),
+                ["instanceId"] = go.GetId(),
                 ["name"] = go.name
             };
         }
@@ -140,7 +152,12 @@ namespace UCP.Bridge
                 string prefabPath = prefabObj.ToString();
                 var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
                 if (prefab == null)
-                    throw new ArgumentException($"Prefab not found: {prefabPath}");
+                {
+                    var hint = LooksLikePrimitive(prefabPath)
+                        ? " To create a built-in primitive, use object create with a primitive instead (e.g. `ucp object create MyCube --primitive Cube`); instantiate is only for prefab assets under Assets/."
+                        : string.Empty;
+                    throw new ArgumentException($"Prefab not found: {prefabPath}.{hint}");
+                }
                 source = prefab;
             }
             // Instantiate from existing scene object (clone)
@@ -192,7 +209,7 @@ namespace UCP.Bridge
             return new Dictionary<string, object>
             {
                 ["status"] = "ok",
-                ["instanceId"] = instance.GetInstanceID(),
+                ["instanceId"] = instance.GetId(),
                 ["name"] = instance.name
             };
         }
@@ -267,6 +284,40 @@ namespace UCP.Bridge
             };
         }
 
+        private static bool LooksLikePrimitive(string path)
+        {
+            if (string.IsNullOrEmpty(path)) return false;
+            var token = path.Replace("PrimitiveType.", "").Trim();
+            switch (token.ToLowerInvariant())
+            {
+                case "cube":
+                case "sphere":
+                case "capsule":
+                case "cylinder":
+                case "plane":
+                case "quad":
+                    return true;
+                default:
+                    return path.IndexOf("PrimitiveType", System.StringComparison.OrdinalIgnoreCase) >= 0;
+            }
+        }
+
+        private static PrimitiveType ParsePrimitive(string value)
+        {
+            switch (value.Trim().ToLowerInvariant())
+            {
+                case "cube": return PrimitiveType.Cube;
+                case "sphere": return PrimitiveType.Sphere;
+                case "capsule": return PrimitiveType.Capsule;
+                case "cylinder": return PrimitiveType.Cylinder;
+                case "plane": return PrimitiveType.Plane;
+                case "quad": return PrimitiveType.Quad;
+                default:
+                    throw new ArgumentException(
+                        $"Unknown primitive '{value}'. Use one of: Cube, Sphere, Capsule, Cylinder, Plane, Quad.");
+            }
+        }
+
         private static Type ResolveComponentType(string typeName)
         {
             // Try exact match first
@@ -314,7 +365,7 @@ namespace UCP.Bridge
 
         private static GameObject FindInHierarchy(GameObject go, int instanceId)
         {
-            if (go.GetInstanceID() == instanceId) return go;
+            if (go.GetId() == instanceId) return go;
             for (int i = 0; i < go.transform.childCount; i++)
             {
                 var found = FindInHierarchy(go.transform.GetChild(i).gameObject, instanceId);