@mflrevan/ucp 0.2.3 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.2.3` of the Unity Control Protocol CLI.
+Version `0.3.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.
 
@@ -42,12 +42,14 @@ ucp build targets
 ucp install
 ```
 
+Default `ucp install` writes a tracked git dependency to `Packages/manifest.json` pinned to the CLI version. It does not write a local `file:` dependency unless you explicitly choose a local embedded mode.
+
 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.2.3"
+    "com.ucp.bridge": "https://github.com/mflRevan/unity-control-protocol.git?path=unity-package/com.ucp.bridge#v0.3.0"
   }
 }
 ```

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

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.3.0] - 2026-03-13
+
+### Added
+
+- Dirty-scene automation controls in bridge scene/play handlers so unattended CLI workflows can avoid save-confirmation modal interruptions.
+
+### Changed
+
+- Scene load and play entry now auto-handle dirty scenes by default for non-interactive automation flows.
+
+### Fixed
+
+- Fixed edit-mode test execution when called during Play Mode by deferring run start until Play Mode exits.
+- Fixed workflow interruptions caused by Unity save-scene prompts during scene transitions and play mode entry.
+
 ## [0.2.3] - 2026-03-12
 
 ### Fixed

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.2.3";
+        private const string ProtocolVersion = "0.3.0";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;

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

@@ -1,4 +1,7 @@
 using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+using System.Collections.Generic;
 
 namespace UCP.Bridge
 {
@@ -16,10 +19,53 @@ namespace UCP.Bridge
             if (EditorApplication.isPlaying)
                 return new { status = "already_playing" };
 
+            var saveDirtyScenes = GetBoolParam(paramsJson, "saveDirtyScenes", true);
+            var discardUntitled = GetBoolParam(paramsJson, "discardUntitled", true);
+            SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
+
             EditorApplication.isPlaying = true;
             return new { status = "ok" };
         }
 
+        private static bool GetBoolParam(string paramsJson, string key, bool defaultValue)
+        {
+            var parameters = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (parameters != null && parameters.TryGetValue(key, out var valueObj) && valueObj is bool value)
+                return value;
+
+            return defaultValue;
+        }
+
+        private static void SaveDirtyScenesIfRequested(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}");
+            }
+
+            if (requiresUntitledDiscard)
+                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+        }
+
         private static object HandleStop(string paramsJson)
         {
             if (!EditorApplication.isPlaying)

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

@@ -40,6 +40,8 @@ namespace UCP.Bridge
                 throw new System.ArgumentException("Missing 'path' parameter");
 
             var path = pathObj.ToString();
+            var saveDirtyScenes = GetBoolParam(p, "saveDirtyScenes", true);
+            var discardUntitled = GetBoolParam(p, "discardUntitled", true);
 
             if (EditorApplication.isPlaying)
             {
@@ -47,12 +49,51 @@ namespace UCP.Bridge
             }
             else
             {
-                EditorSceneManager.OpenScene(path);
+                SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
+                EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
             }
 
             return new { status = "ok", loaded = path };
         }
 
+        private static bool GetBoolParam(Dictionary<string, object> parameters, string key, bool defaultValue)
+        {
+            if (parameters != null && parameters.TryGetValue(key, out var valueObj) && valueObj is bool value)
+                return value;
+
+            return defaultValue;
+        }
+
+        private static void SaveDirtyScenesIfRequested(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}");
+            }
+
+            if (requiresUntitledDiscard)
+                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+        }
+
         private static object HandleActive(string paramsJson)
         {
             var scene = SceneManager.GetActiveScene();

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

@@ -55,7 +55,21 @@ namespace UCP.Bridge
                 executionSettings.filters[0].testNames = new[] { filter };
             }
 
-            s_api.Execute(executionSettings);
+            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.
@@ -63,7 +77,53 @@ namespace UCP.Bridge
             {
                 ["status"] = "started",
                 ["mode"] = mode,
-                ["message"] = "Tests started. Results will arrive as notifications."
+                ["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);
             };
         }
 

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

@@ -1,15 +1,21 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Text.RegularExpressions;
 using NUnit.Framework;
 using UnityEditor;
 using UnityEditor.SceneManagement;
 using UnityEngine;
+using UnityEngine.TestTools;
 
 namespace UCP.Bridge.Tests
 {
     public class ControllerSmokeTests
     {
         private const string TempAssetPath = "Assets/UcpControllerSmoke.asset";
+        private const string TempPrefabPath = "Assets/UcpControllerSmoke.prefab";
+        private const string TempMaterialPath = "Assets/UcpControllerSmoke.mat";
+        private const string TempTextPath = "Assets/UcpControllerSmoke.txt";
 
         private CommandRouter _router;
 
@@ -20,8 +26,18 @@ namespace UCP.Bridge.Tests
             SnapshotController.Register(_router);
             AssetController.Register(_router);
             LogsController.Register(_router);
+            HierarchyController.Register(_router);
+            PropertyController.Register(_router);
+            FileController.Register(_router);
+            MaterialController.Register(_router);
+            PrefabController.Register(_router);
+            BuildController.Register(_router);
+            EditorSettingsController.Register(_router);
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
             DeleteTempAsset();
+            DeleteTempPrefab();
+            DeleteTempMaterial();
+            DeleteTempTextFile();
             LogsController.ClearHistoryForTests();
         }
 
@@ -29,6 +45,9 @@ namespace UCP.Bridge.Tests
         public void TearDown()
         {
             DeleteTempAsset();
+            DeleteTempPrefab();
+            DeleteTempMaterial();
+            DeleteTempTextFile();
             LogsController.ClearHistoryForTests();
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
         }
@@ -76,17 +95,18 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "asset/search",
                 1,
-                "{\"type\":\"SearchNestedAsset\",\"name\":\"SmokeNested\",\"path\":\"Assets\",\"maxResults\":10}"
+                "{\"name\":\"SmokeNested\",\"path\":\"Assets\",\"maxResults\":10}"
             );
 
             Assert.That(response.error, Is.Null);
 
             var result = (Dictionary<string, object>)response.result;
-            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(1));
-            Assert.That(Convert.ToInt32(result["returned"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(result["total"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(Convert.ToInt32(result["returned"]), Is.GreaterThanOrEqualTo(1));
 
             var matches = (List<object>)result["results"];
-            var match = (Dictionary<string, object>)matches[0];
+            var match = FindAssetMatch(matches, TempAssetPath, "SmokeNested");
+            Assert.That(match, Is.Not.Null);
             Assert.That(match["path"], Is.EqualTo(TempAssetPath));
             Assert.That(match["type"], Is.EqualTo("SearchNestedAsset"));
             Assert.That(match["name"], Is.EqualTo("SmokeNested"));
@@ -174,6 +194,214 @@ namespace UCP.Bridge.Tests
             Assert.That(result["stackTrace"], Is.EqualTo("stack line 1\nstack line 2"));
         }
 
+        [Test]
+        public void ObjectLifecycle_CreateMutateAndDelete_WorksEndToEnd()
+        {
+            var create = _router.Dispatch("object/create", 1, "{\"name\":\"SmokeObject\"}");
+            Assert.That(create.error, Is.Null);
+
+            var createResult = (Dictionary<string, object>)create.result;
+            var instanceId = Convert.ToInt32(createResult["instanceId"]);
+
+            var rename = _router.Dispatch("object/set-name", 1, "{\"instanceId\":" + instanceId + ",\"name\":\"RenamedSmoke\"}");
+            Assert.That(rename.error, Is.Null);
+
+            var deactivate = _router.Dispatch("object/set-active", 1, "{\"instanceId\":" + instanceId + ",\"active\":false}");
+            Assert.That(deactivate.error, Is.Null);
+            var deactivateResult = (Dictionary<string, object>)deactivate.result;
+            Assert.That(Convert.ToBoolean(deactivateResult["active"]), Is.False);
+
+            var activate = _router.Dispatch("object/set-active", 1, "{\"instanceId\":" + instanceId + ",\"active\":true}");
+            Assert.That(activate.error, Is.Null);
+
+            var addComponent = _router.Dispatch("object/add-component", 1, "{\"instanceId\":" + instanceId + ",\"type\":\"BoxCollider\"}");
+            Assert.That(addComponent.error, Is.Null);
+
+            var setPosition = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\",\"value\":[1,2,3]}"
+            );
+            Assert.That(setPosition.error, Is.Null);
+
+            var getPosition = _router.Dispatch(
+                "object/get-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\"}"
+            );
+            Assert.That(getPosition.error, Is.Null);
+
+            var updated = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+            Assert.That(updated, Is.Not.Null);
+            var localPosition = updated.transform.localPosition;
+            Assert.That(localPosition.x, Is.EqualTo(1f).Within(0.001f));
+            Assert.That(localPosition.y, Is.EqualTo(2f).Within(0.001f));
+            Assert.That(localPosition.z, Is.EqualTo(3f).Within(0.001f));
+
+            var removeComponent = _router.Dispatch("object/remove-component", 1, "{\"instanceId\":" + instanceId + ",\"type\":\"BoxCollider\"}");
+            Assert.That(removeComponent.error, Is.Null);
+
+            var delete = _router.Dispatch("object/delete", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(delete.error, Is.Null);
+            Assert.That(EditorUtility.InstanceIDToObject(instanceId), Is.Null);
+        }
+
+        [Test]
+        public void FileController_WritePatchRead_AndRejectsPathTraversal()
+        {
+            var write = _router.Dispatch("file/write", 1, "{\"path\":\"Assets/UcpControllerSmoke.txt\",\"content\":\"hello smoke\"}");
+            Assert.That(write.error, Is.Null);
+
+            var patch = _router.Dispatch(
+                "file/patch",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.txt\",\"patch\":{\"find\":\"smoke\",\"replace\":\"patched\"}}"
+            );
+            Assert.That(patch.error, Is.Null);
+
+            var read = _router.Dispatch("file/read", 1, "{\"path\":\"Assets/UcpControllerSmoke.txt\"}");
+            Assert.That(read.error, Is.Null);
+            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);
+        }
+
+        [Test]
+        public void MaterialController_SetAndGetFloatProperty_RoundTrips()
+        {
+            var shader = Shader.Find("Standard") ?? Shader.Find("Universal Render Pipeline/Lit");
+            Assert.That(shader, Is.Not.Null);
+
+            var propertyName = FindFirstFloatOrRangeProperty(shader);
+            Assert.That(propertyName, Is.Not.Null.And.Not.Empty);
+
+            var material = new Material(shader) { name = "UcpControllerSmokeMat" };
+            AssetDatabase.CreateAsset(material, TempMaterialPath);
+            AssetDatabase.SaveAssets();
+
+            var set = _router.Dispatch(
+                "material/set-property",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.mat\",\"property\":\"" + propertyName + "\",\"value\":0.42}"
+            );
+            Assert.That(set.error, Is.Null);
+
+            var get = _router.Dispatch(
+                "material/get-property",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.mat\",\"property\":\"" + propertyName + "\"}"
+            );
+            Assert.That(get.error, Is.Null);
+
+            var getResult = (Dictionary<string, object>)get.result;
+            var value = Convert.ToSingle(getResult["value"]);
+            Assert.That(value, Is.EqualTo(0.42f).Within(0.001f));
+        }
+
+        [Test]
+        public void PrefabController_CreateStatusOverridesAndUnpack_Works()
+        {
+            var create = _router.Dispatch("object/create", 1, "{\"name\":\"PrefabSource\"}");
+            Assert.That(create.error, Is.Null);
+            var sourceId = Convert.ToInt32(((Dictionary<string, object>)create.result)["instanceId"]);
+
+            var createPrefab = _router.Dispatch(
+                "prefab/create",
+                1,
+                "{\"instanceId\":" + sourceId + ",\"path\":\"Assets/UcpControllerSmoke.prefab\"}"
+            );
+            Assert.That(createPrefab.error, Is.Null);
+
+            var instantiate = _router.Dispatch(
+                "object/instantiate",
+                1,
+                "{\"prefab\":\"Assets/UcpControllerSmoke.prefab\",\"name\":\"PrefabInstance\"}"
+            );
+            Assert.That(instantiate.error, Is.Null);
+            var instanceId = Convert.ToInt32(((Dictionary<string, object>)instantiate.result)["instanceId"]);
+
+            var status = _router.Dispatch("prefab/status", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(status.error, Is.Null);
+            var statusResult = (Dictionary<string, object>)status.result;
+            Assert.That(Convert.ToBoolean(statusResult["isInstance"]), Is.True);
+
+            var mutate = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\",\"value\":[2,0,0]}"
+            );
+            Assert.That(mutate.error, Is.Null);
+
+            var overrides = _router.Dispatch("prefab/overrides", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(overrides.error, Is.Null);
+            var overridesResult = (Dictionary<string, object>)overrides.result;
+            var modifications = (List<object>)overridesResult["propertyModifications"];
+            Assert.That(modifications.Count, Is.GreaterThanOrEqualTo(1));
+
+            var unpack = _router.Dispatch("prefab/unpack", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(unpack.error, Is.Null);
+
+            var unpackedStatus = _router.Dispatch("prefab/status", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(unpackedStatus.error, Is.Null);
+            var unpackedStatusResult = (Dictionary<string, object>)unpackedStatus.result;
+            Assert.That(Convert.ToBoolean(unpackedStatusResult["isInstance"]), Is.False);
+        }
+
+        [Test]
+        public void SettingsAndBuildControllers_RoundTripWithoutSideEffects()
+        {
+            var playerSettings = _router.Dispatch("settings/player", 1, "{}");
+            Assert.That(playerSettings.error, Is.Null);
+            var settingsResult = (Dictionary<string, object>)playerSettings.result;
+            var originalProductName = settingsResult["productName"].ToString();
+
+            var setPlayer = _router.Dispatch(
+                "settings/player-set",
+                1,
+                "{\"key\":\"productName\",\"value\":\"UcpQaProduct\"}"
+            );
+            Assert.That(setPlayer.error, Is.Null);
+
+            var verifyPlayer = _router.Dispatch("settings/player", 1, "{}");
+            Assert.That(verifyPlayer.error, Is.Null);
+            var verifyResult = (Dictionary<string, object>)verifyPlayer.result;
+            Assert.That(verifyResult["productName"].ToString(), Is.EqualTo("UcpQaProduct"));
+
+            var restorePlayer = _router.Dispatch(
+                "settings/player-set",
+                1,
+                "{\"key\":\"productName\",\"value\":\"" + originalProductName + "\"}"
+            );
+            Assert.That(restorePlayer.error, Is.Null);
+
+            var scenes = _router.Dispatch("build/scenes", 1, "{}");
+            Assert.That(scenes.error, Is.Null);
+            var scenesResult = (Dictionary<string, object>)scenes.result;
+            var currentScenes = (List<object>)scenesResult["scenes"];
+            Assert.That(currentScenes.Count, Is.GreaterThanOrEqualTo(1));
+
+            var firstScene = (Dictionary<string, object>)currentScenes[0];
+            var firstScenePath = firstScene["path"].ToString();
+
+            var setScenes = _router.Dispatch(
+                "build/set-scenes",
+                1,
+                "{\"scenes\":[\"" + EscapeForJson(firstScenePath) + "\"]}"
+            );
+            Assert.That(setScenes.error, Is.Null);
+
+            var defines = _router.Dispatch("build/defines", 1, "{}");
+            Assert.That(defines.error, Is.Null);
+            var definesResult = (Dictionary<string, object>)defines.result;
+            var originalDefines = definesResult["defines"].ToString();
+
+            var setDefines = _router.Dispatch("build/set-defines", 1, "{\"defines\":\"" + EscapeForJson(originalDefines) + "\"}");
+            Assert.That(setDefines.error, Is.Null);
+        }
+
         private static void DeleteTempAsset()
         {
             if (AssetDatabase.LoadMainAssetAtPath(TempAssetPath) != null)
@@ -183,6 +411,69 @@ namespace UCP.Bridge.Tests
             }
         }
 
+        private static void DeleteTempPrefab()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempPrefabPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempPrefabPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempMaterial()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempMaterialPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempMaterialPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempTextFile()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempTextPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempTextPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static string FindFirstFloatOrRangeProperty(Shader shader)
+        {
+            for (var index = 0; index < shader.GetPropertyCount(); index++)
+            {
+                var propertyType = shader.GetPropertyType(index);
+                if (propertyType == UnityEngine.Rendering.ShaderPropertyType.Float
+                    || propertyType == UnityEngine.Rendering.ShaderPropertyType.Range)
+                {
+                    return shader.GetPropertyName(index);
+                }
+            }
+
+            return null;
+        }
+
+        private static string EscapeForJson(string value)
+        {
+            return value
+                .Replace("\\", "\\\\")
+                .Replace("\"", "\\\"");
+        }
+
+        private static Dictionary<string, object> FindAssetMatch(List<object> matches, string expectedPath, string expectedName)
+        {
+            foreach (var entry in matches)
+            {
+                var match = (Dictionary<string, object>)entry;
+                var path = match.ContainsKey("path") ? match["path"].ToString() : string.Empty;
+                var name = match.ContainsKey("name") ? match["name"].ToString() : string.Empty;
+                if (path == expectedPath && name == expectedName)
+                    return match;
+            }
+
+            return null;
+        }
+
         private sealed class SearchRootAsset : ScriptableObject
         {
         }

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

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