@mflrevan/ucp 0.3.2 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.3.2` of the Unity Control Protocol CLI.
+Version `0.4.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.
 
@@ -30,7 +30,7 @@ pnpm approve-builds
 cd /path/to/MyUnityProject
 ucp doctor
 ucp connect
-ucp snapshot
+ucp scene snapshot
 ucp object get-fields --id 46894 --component Transform
 ucp asset search -t Material
 ucp build targets
@@ -49,7 +49,7 @@ Or add this to `Packages/manifest.json`:
 ```json
 {
   "dependencies": {
-    "com.ucp.bridge": "https://github.com/mflRevan/unity-control-protocol.git?path=unity-package/com.ucp.bridge#v0.3.2"
+    "com.ucp.bridge": "https://github.com/mflRevan/unity-control-protocol.git?path=unity-package/com.ucp.bridge#v0.4.0"
   }
 }
 ```

package/bridge/com.ucp.bridge/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [0.4.0] - 2026-03-15
+
+### Added
+
+- Added `scene/focus` so the CLI can align the Unity Scene view to a target object for screenshot-driven iteration.
+- Added smoke coverage for asset refresh after `file/write` and Scene view focus axis handling.
+
+### Changed
+
+- `scene/focus` now exposes the stable axis-alignment workflow only, without public distance overrides.
+
+### Fixed
+
+- Fixed `file/write` and `file/patch` so changes under `Assets/` and `Packages/` trigger a synchronous `AssetDatabase.Refresh`, making newly created scripts and assets available immediately.
+- Fixed Scene view focus behavior and validation coverage so live automation and package smoke tests agree on the resulting alignment.
+
+## [0.3.3] - 2026-03-14
+
+### Added
+
+- Added missing Unity metadata for `EditorController.cs` and `ObjectReferenceResolver.cs` so both controllers import reliably in embedded and tracked package installs.
+
+### Changed
+
+- `CommandRouter` now maps `ArgumentException` to `InvalidParams` and `UnauthorizedAccessException` to `FileAccessDenied` without emitting misleading internal-error logs.
+
+### Fixed
+
+- Fixed negative smoke tests around unresolved object references and project-root path traversal.
+
 ## [0.3.2] - 2026-03-14
 
 ### Added

package/bridge/com.ucp.bridge/Editor/Bridge/BridgeServer.cs

@@ -26,7 +26,7 @@ namespace UCP.Bridge
         private const int DefaultPort = 21342;
         private const int MaxPort = 21352;
         private const int MaxConnections = 4;
-        private const string ProtocolVersion = "0.3.2";
+        private const string ProtocolVersion = "0.4.0";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4dfae33b6e324de8b6502bbf8e3e44cd

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using UnityEditor;
 using UnityEngine;
 
 namespace UCP.Bridge
@@ -67,6 +68,7 @@ namespace UCP.Bridge
                 Directory.CreateDirectory(dir);
 
             File.WriteAllText(fullPath, contentObj.ToString());
+            RefreshProjectAssets(pathObj.ToString());
 
             return new Dictionary<string, object>
             {
@@ -116,6 +118,7 @@ namespace UCP.Bridge
 
                 var patched = original.Replace(find, replace);
                 File.WriteAllText(fullPath, patched);
+                RefreshProjectAssets(pathObj.ToString());
 
                 return new Dictionary<string, object>
                 {
@@ -126,5 +129,17 @@ namespace UCP.Bridge
 
             throw new ArgumentException("Unsupported patch format. Use {\"find\": \"...\", \"replace\": \"...\"}");
         }
+
+        private static void RefreshProjectAssets(string relativePath)
+        {
+            var normalized = relativePath.Replace('\\', '/');
+            if (normalized.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)
+                || normalized.Equals("Assets", StringComparison.OrdinalIgnoreCase)
+                || normalized.StartsWith("Packages/", StringComparison.OrdinalIgnoreCase)
+                || normalized.Equals("Packages", StringComparison.OrdinalIgnoreCase))
+            {
+                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            }
+        }
     }
 }

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3e6a1ac0c4ee4782a482cc62f85e5313

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

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEditor.SceneManagement;
+using UnityEngine;
 using UnityEngine.SceneManagement;
 
 namespace UCP.Bridge
@@ -12,6 +13,7 @@ namespace UCP.Bridge
             router.Register("scene/list", HandleList);
             router.Register("scene/load", HandleLoad);
             router.Register("scene/active", HandleActive);
+            router.Register("scene/focus", HandleFocus);
         }
 
         private static object HandleList(string paramsJson)
@@ -107,5 +109,161 @@ namespace UCP.Bridge
                 ["rootCount"] = scene.rootCount
             };
         }
+
+        private static object HandleFocus(string paramsJson)
+        {
+            var parameters = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (parameters == null || !parameters.TryGetValue("instanceId", out var idObj))
+                throw new System.ArgumentException("Missing 'instanceId' parameter");
+
+            var instanceId = System.Convert.ToInt32(idObj);
+            var target = FindGameObject(instanceId);
+            var bounds = CalculateFocusBounds(target);
+            var sceneView = SceneView.lastActiveSceneView ?? EditorWindow.GetWindow<SceneView>();
+
+            if (sceneView == null)
+                throw new System.InvalidOperationException("Unable to open Scene view");
+
+            sceneView.Show();
+            sceneView.Focus();
+            Selection.activeGameObject = target;
+
+            var focusPoint = bounds.center;
+            var focusSize = Mathf.Max(bounds.extents.magnitude * 2f, 1f);
+            var axis = TryReadAxis(parameters);
+
+            if (axis.HasValue)
+            {
+                var normalizedAxis = axis.Value.normalized;
+                var rotation = Quaternion.LookRotation(-normalizedAxis, SelectUpVector(normalizedAxis));
+                sceneView.LookAtDirect(focusPoint, rotation, focusSize);
+            }
+            else
+            {
+                sceneView.LookAtDirect(focusPoint, sceneView.rotation, focusSize);
+            }
+
+            sceneView.Repaint();
+            SceneView.RepaintAll();
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["name"] = target.name,
+                ["pivot"] = VectorToList(sceneView.pivot),
+                ["cameraPosition"] = VectorToList(sceneView.camera.transform.position),
+                ["cameraRotationEuler"] = VectorToList(sceneView.camera.transform.rotation.eulerAngles),
+                ["size"] = sceneView.size,
+                ["axis"] = axis.HasValue ? VectorToList(axis.Value.normalized) : null
+            };
+        }
+
+        private static Vector3? TryReadAxis(Dictionary<string, object> parameters)
+        {
+            if (parameters == null || !parameters.TryGetValue("axis", out var axisObj) || axisObj == null)
+                return null;
+
+            if (axisObj is not List<object> values || values.Count != 3)
+                throw new System.ArgumentException("axis must be an array of exactly three numeric values");
+
+            var axis = new Vector3(
+                System.Convert.ToSingle(values[0]),
+                System.Convert.ToSingle(values[1]),
+                System.Convert.ToSingle(values[2]));
+
+            if (axis.sqrMagnitude < 0.0001f)
+                throw new System.ArgumentException("axis must not be the zero vector");
+
+            return axis;
+        }
+
+        private static Vector3 SelectUpVector(Vector3 axis)
+        {
+            if (Mathf.Abs(Vector3.Dot(axis, Vector3.up)) > 0.98f)
+                return Vector3.forward;
+
+            return Vector3.up;
+        }
+
+        private static Bounds CalculateFocusBounds(GameObject target)
+        {
+            var hasBounds = false;
+            var bounds = new Bounds(target.transform.position, Vector3.one);
+
+            foreach (var renderer in target.GetComponentsInChildren<Renderer>())
+            {
+                if (!hasBounds)
+                {
+                    bounds = renderer.bounds;
+                    hasBounds = true;
+                }
+                else
+                {
+                    bounds.Encapsulate(renderer.bounds);
+                }
+            }
+
+            foreach (var collider in target.GetComponentsInChildren<Collider>())
+            {
+                if (!hasBounds)
+                {
+                    bounds = collider.bounds;
+                    hasBounds = true;
+                }
+                else
+                {
+                    bounds.Encapsulate(collider.bounds);
+                }
+            }
+
+            if (!hasBounds)
+                bounds = new Bounds(target.transform.position, Vector3.one);
+
+            return bounds;
+        }
+
+        private static GameObject FindGameObject(int instanceId)
+        {
+            var direct = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+            if (direct != null)
+                return direct;
+
+            for (var index = 0; index < SceneManager.sceneCount; index++)
+            {
+                var scene = SceneManager.GetSceneAt(index);
+                if (!scene.isLoaded)
+                    continue;
+
+                foreach (var root in scene.GetRootGameObjects())
+                {
+                    var found = FindInHierarchy(root, instanceId);
+                    if (found != null)
+                        return found;
+                }
+            }
+
+            throw new System.ArgumentException($"GameObject not found: {instanceId}");
+        }
+
+        private static GameObject FindInHierarchy(GameObject gameObject, int instanceId)
+        {
+            if (gameObject.GetInstanceID() == instanceId)
+                return gameObject;
+
+            foreach (Transform child in gameObject.transform)
+            {
+                var found = FindInHierarchy(child.gameObject, instanceId);
+                if (found != null)
+                    return found;
+            }
+
+            return null;
+        }
+
+        private static List<object> VectorToList(Vector3 value)
+        {
+            return new List<object> { value.x, value.y, value.z };
+        }
     }
 }

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

@@ -31,6 +31,14 @@ namespace UCP.Bridge
                 var result = handler(paramsJson);
                 return JsonRpcResponse.Success(id, result);
             }
+            catch (ArgumentException ex)
+            {
+                return JsonRpcResponse.Error(id, ErrorCodes.InvalidParams, ex.Message);
+            }
+            catch (UnauthorizedAccessException ex)
+            {
+                return JsonRpcResponse.Error(id, ErrorCodes.FileAccessDenied, ex.Message);
+            }
             catch (Exception ex)
             {
                 Debug.LogError($"[UCP] Error handling '{method}': {ex}");

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

@@ -17,6 +17,7 @@ namespace UCP.Bridge.Tests
         private const string TempPrefabPath = "Assets/UcpControllerSmoke.prefab";
         private const string TempMaterialPath = "Assets/UcpControllerSmoke.mat";
         private const string TempTextPath = "Assets/UcpControllerSmoke.txt";
+        private const string TempScriptPath = "Assets/UcpControllerSmokeComponent.cs";
 
         private CommandRouter _router;
 
@@ -34,12 +35,14 @@ namespace UCP.Bridge.Tests
             PrefabController.Register(_router);
             BuildController.Register(_router);
             EditorSettingsController.Register(_router);
+            SceneController.Register(_router);
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
             DeleteTempAsset();
             DeleteTempReferenceAsset();
             DeleteTempPrefab();
             DeleteTempMaterial();
             DeleteTempTextFile();
+            DeleteTempScriptFile();
             LogsController.ClearHistoryForTests();
         }
 
@@ -51,6 +54,7 @@ namespace UCP.Bridge.Tests
             DeleteTempPrefab();
             DeleteTempMaterial();
             DeleteTempTextFile();
+            DeleteTempScriptFile();
             LogsController.ClearHistoryForTests();
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
         }
@@ -301,6 +305,7 @@ namespace UCP.Bridge.Tests
             );
 
             Assert.That(response.error, Is.Not.Null);
+            Assert.That(response.error.code, Is.EqualTo(ErrorCodes.InvalidParams));
         }
 
         [Test]
@@ -348,9 +353,75 @@ namespace UCP.Bridge.Tests
             var readResult = (Dictionary<string, object>)read.result;
             Assert.That(readResult["content"].ToString(), Is.EqualTo("hello patched"));
 
-            LogAssert.Expect(LogType.Error, new Regex("\\[UCP\\] Error handling 'file/read':"));
             var traversal = _router.Dispatch("file/read", 1, "{\"path\":\"../outside.txt\"}");
             Assert.That(traversal.error, Is.Not.Null);
+            Assert.That(traversal.error.code, Is.EqualTo(ErrorCodes.FileAccessDenied));
+        }
+
+        [Test]
+        public void FileController_Write_RefreshesAssetDatabaseForNewAssets()
+        {
+            var write = _router.Dispatch(
+                "file/write",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmokeComponent.cs\",\"content\":\"using UnityEngine; public class UcpControllerSmokeComponent : MonoBehaviour {}\"}"
+            );
+
+            Assert.That(write.error, Is.Null);
+
+            var script = AssetDatabase.LoadAssetAtPath<MonoScript>(TempScriptPath);
+            Assert.That(script, Is.Not.Null);
+            Assert.That(script.name, Is.EqualTo("UcpControllerSmokeComponent"));
+        }
+
+        [Test]
+        public void SceneFocus_WithAxis_AlignsSceneCameraTowardTarget()
+        {
+            var sceneView = EditorWindow.GetWindow<SceneView>();
+            var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            cube.name = "FocusTarget";
+            cube.transform.position = new Vector3(2f, 1f, 3f);
+            cube.transform.localScale = new Vector3(2f, 2f, 2f);
+
+            var response = _router.Dispatch(
+                "scene/focus",
+                1,
+                "{\"instanceId\":" + cube.GetInstanceID() + ",\"axis\":[1,0,1]}"
+            );
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(result["name"].ToString(), Is.EqualTo("FocusTarget"));
+            Assert.That(Selection.activeGameObject, Is.EqualTo(cube));
+
+            var expectedDirection = new Vector3(1f, 0f, 1f).normalized;
+            var axisData = (List<object>)result["axis"];
+            var returnedAxis = new Vector3(
+                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.That(Vector3.Distance(sceneView.pivot, cube.transform.position), Is.LessThan(2f));
+        }
+
+        [Test]
+        public void SceneFocus_RejectsZeroAxisVector()
+        {
+            EditorWindow.GetWindow<SceneView>();
+            var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            cube.name = "ZeroAxisTarget";
+
+            var response = _router.Dispatch(
+                "scene/focus",
+                1,
+                "{\"instanceId\":" + cube.GetInstanceID() + ",\"axis\":[0,0,0]}"
+            );
+
+            Assert.That(response.error, Is.Not.Null);
+            Assert.That(response.error.code, Is.EqualTo(ErrorCodes.InvalidParams));
         }
 
         [Test]
@@ -531,6 +602,15 @@ namespace UCP.Bridge.Tests
             }
         }
 
+        private static void DeleteTempScriptFile()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempScriptPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempScriptPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
         private static string FindFirstFloatOrRangeProperty(Shader shader)
         {
             for (var index = 0; index < shader.GetPropertyCount(); index++)

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

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "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.3.2",
+  "version": "0.4.0",
   "description": "Unity Control Protocol — CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {