@mflrevan/ucp 0.4.4 → 0.4.5

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

@@ -0,0 +1,527 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UCP.Bridge
+{
+    public static class EditorSettingsController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("settings/player", HandlePlayerSettings);
+            router.Register("settings/player-set", HandleSetPlayerSetting);
+            router.Register("settings/quality", HandleQualitySettings);
+            router.Register("settings/quality-set", HandleSetQualitySetting);
+            router.Register("settings/physics", HandlePhysicsSettings);
+            router.Register("settings/physics-set", HandleSetPhysicsSetting);
+            router.Register("settings/lighting", HandleLightingSettings);
+            router.Register("settings/lighting-set", HandleSetLightingSetting);
+            router.Register("settings/tags-layers", HandleTagsAndLayers);
+            router.Register("settings/add-tag", HandleAddTag);
+            router.Register("settings/add-layer", HandleAddLayer);
+        }
+
+        private static NamedBuildTarget GetSelectedNamedBuildTarget()
+        {
+            return NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
+        }
+
+        private static object HandlePlayerSettings(string paramsJson)
+        {
+            var namedTarget = GetSelectedNamedBuildTarget();
+            return new Dictionary<string, object>
+            {
+                ["companyName"] = PlayerSettings.companyName,
+                ["productName"] = PlayerSettings.productName,
+                ["bundleVersion"] = PlayerSettings.bundleVersion,
+                ["defaultIsNativeResolution"] = PlayerSettings.defaultIsNativeResolution,
+                ["runInBackground"] = PlayerSettings.runInBackground,
+                ["colorSpace"] = PlayerSettings.colorSpace.ToString(),
+                ["graphicsApi"] = PlayerSettings.GetGraphicsAPIs(EditorUserBuildSettings.activeBuildTarget)?[0].ToString() ?? "Unknown",
+                ["scriptingBackend"] = PlayerSettings.GetScriptingBackend(namedTarget).ToString(),
+                ["apiCompatibilityLevel"] = PlayerSettings.GetApiCompatibilityLevel(namedTarget).ToString(),
+                ["activeInputHandler"] = ReadPlayerSettingInt("activeInputHandler"),
+                ["activeInputHandlerName"] = DescribeActiveInputHandler(ReadPlayerSettingInt("activeInputHandler")),
+                ["targetFrameRate"] = Application.targetFrameRate,
+                ["defaultScreenWidth"] = PlayerSettings.defaultScreenWidth,
+                ["defaultScreenHeight"] = PlayerSettings.defaultScreenHeight
+            };
+        }
+
+        private static object HandleSetPlayerSetting(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("key", out var keyObj))
+                throw new ArgumentException("Missing 'key' parameter");
+            if (!p.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            string key = keyObj.ToString();
+            object value = p["value"];
+
+            switch (key)
+            {
+                case "companyName":
+                    PlayerSettings.companyName = value.ToString();
+                    break;
+                case "productName":
+                    PlayerSettings.productName = value.ToString();
+                    break;
+                case "bundleVersion":
+                    PlayerSettings.bundleVersion = value.ToString();
+                    break;
+                case "runInBackground":
+                    PlayerSettings.runInBackground = Convert.ToBoolean(value);
+                    break;
+                case "defaultIsNativeResolution":
+                    PlayerSettings.defaultIsNativeResolution = Convert.ToBoolean(value);
+                    break;
+                case "defaultScreenWidth":
+                    PlayerSettings.defaultScreenWidth = Convert.ToInt32(value);
+                    break;
+                case "defaultScreenHeight":
+                    PlayerSettings.defaultScreenHeight = Convert.ToInt32(value);
+                    break;
+                case "colorSpace":
+                    if (Enum.TryParse<ColorSpace>(value.ToString(), out var cs))
+                        PlayerSettings.colorSpace = cs;
+                    break;
+                case "activeInputHandler":
+                case "activeInputHandling":
+                case "inputHandling":
+                    WritePlayerSettingInt("activeInputHandler", ParseActiveInputHandler(value));
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown player setting: {key}");
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["key"] = key };
+        }
+
+        private static object HandleQualitySettings(string paramsJson)
+        {
+            var names = QualitySettings.names;
+            var levels = new List<object>();
+            for (int i = 0; i < names.Length; i++)
+            {
+                levels.Add(new Dictionary<string, object>
+                {
+                    ["index"] = i,
+                    ["name"] = names[i],
+                    ["isCurrent"] = i == QualitySettings.GetQualityLevel()
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["currentLevel"] = QualitySettings.GetQualityLevel(),
+                ["currentName"] = names[QualitySettings.GetQualityLevel()],
+                ["levels"] = levels,
+                ["shadowDistance"] = (double)QualitySettings.shadowDistance,
+                ["shadowCascades"] = QualitySettings.shadowCascades,
+                ["antiAliasing"] = QualitySettings.antiAliasing,
+                ["vSyncCount"] = QualitySettings.vSyncCount
+            };
+        }
+
+        private static object HandleSetQualitySetting(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("key", out var keyObj))
+                throw new ArgumentException("Missing 'key' parameter");
+            if (!p.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            string key = keyObj.ToString();
+            object value = p["value"];
+
+            switch (key)
+            {
+                case "level":
+                    QualitySettings.SetQualityLevel(Convert.ToInt32(value));
+                    break;
+                case "shadowDistance":
+                    QualitySettings.shadowDistance = Convert.ToSingle(value);
+                    break;
+                case "shadowCascades":
+                    QualitySettings.shadowCascades = Convert.ToInt32(value);
+                    break;
+                case "antiAliasing":
+                    QualitySettings.antiAliasing = Convert.ToInt32(value);
+                    break;
+                case "vSyncCount":
+                    QualitySettings.vSyncCount = Convert.ToInt32(value);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown quality setting: {key}");
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["key"] = key };
+        }
+
+        private static int ReadPlayerSettingInt(string propertyName)
+        {
+            var serialized = new SerializedObject(GetPlayerSettingsAsset());
+            var property = serialized.FindProperty(propertyName);
+            if (property == null)
+                throw new ArgumentException($"Unknown serialized player setting: {propertyName}");
+
+            return property.intValue;
+        }
+
+        private static void WritePlayerSettingInt(string propertyName, int value)
+        {
+            var serialized = new SerializedObject(GetPlayerSettingsAsset());
+            var property = serialized.FindProperty(propertyName);
+            if (property == null)
+                throw new ArgumentException($"Unknown serialized player setting: {propertyName}");
+
+            property.intValue = value;
+            serialized.ApplyModifiedPropertiesWithoutUndo();
+            AssetDatabase.SaveAssets();
+        }
+
+        private static UnityEngine.Object GetPlayerSettingsAsset()
+        {
+            var asset = Unsupported.GetSerializedAssetInterfaceSingleton("PlayerSettings");
+            if (asset == null)
+                throw new InvalidOperationException("Unable to resolve PlayerSettings serialized asset");
+
+            return asset;
+        }
+
+        private static int ParseActiveInputHandler(object value)
+        {
+            if (value == null)
+                throw new ArgumentException("Input handling value cannot be null");
+
+            if (int.TryParse(value.ToString(), out var numeric))
+            {
+                if (numeric < 0 || numeric > 2)
+                    throw new ArgumentException("activeInputHandler must be 0 (Old), 1 (Input System), or 2 (Both)");
+                return numeric;
+            }
+
+            switch (value.ToString().Trim().ToLowerInvariant())
+            {
+                case "old":
+                case "legacy":
+                case "inputmanager":
+                    return 0;
+                case "new":
+                case "inputsystem":
+                case "inputsystempackage":
+                    return 1;
+                case "both":
+                    return 2;
+                default:
+                    throw new ArgumentException("activeInputHandler must be one of: old, inputsystem, both, 0, 1, 2");
+            }
+        }
+
+        private static string DescribeActiveInputHandler(int value)
+        {
+            switch (value)
+            {
+                case 0:
+                    return "Old";
+                case 1:
+                    return "InputSystemPackage";
+                case 2:
+                    return "Both";
+                default:
+                    return $"Unknown({value})";
+            }
+        }
+
+        private static object HandlePhysicsSettings(string paramsJson)
+        {
+            return new Dictionary<string, object>
+            {
+                ["gravity"] = new List<object>
+                {
+                    (double)Physics.gravity.x,
+                    (double)Physics.gravity.y,
+                    (double)Physics.gravity.z
+                },
+                ["defaultSolverIterations"] = Physics.defaultSolverIterations,
+                ["defaultSolverVelocityIterations"] = Physics.defaultSolverVelocityIterations,
+                ["bounceThreshold"] = (double)Physics.bounceThreshold,
+                ["sleepThreshold"] = (double)Physics.sleepThreshold,
+                ["defaultContactOffset"] = (double)Physics.defaultContactOffset,
+                ["autoSimulation"] = Physics.simulationMode.ToString()
+            };
+        }
+
+        private static object HandleSetPhysicsSetting(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("key", out var keyObj))
+                throw new ArgumentException("Missing 'key' parameter");
+            if (!p.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            string key = keyObj.ToString();
+            object value = p["value"];
+
+            switch (key)
+            {
+                case "gravity":
+                    if (value is List<object> g && g.Count >= 3)
+                        Physics.gravity = new Vector3(
+                            Convert.ToSingle(g[0]),
+                            Convert.ToSingle(g[1]),
+                            Convert.ToSingle(g[2]));
+                    break;
+                case "defaultSolverIterations":
+                    Physics.defaultSolverIterations = Convert.ToInt32(value);
+                    break;
+                case "defaultSolverVelocityIterations":
+                    Physics.defaultSolverVelocityIterations = Convert.ToInt32(value);
+                    break;
+                case "bounceThreshold":
+                    Physics.bounceThreshold = Convert.ToSingle(value);
+                    break;
+                case "sleepThreshold":
+                    Physics.sleepThreshold = Convert.ToSingle(value);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown physics setting: {key}");
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["key"] = key };
+        }
+
+        private static object HandleLightingSettings(string paramsJson)
+        {
+            var result = new Dictionary<string, object>
+            {
+                ["ambientMode"] = RenderSettings.ambientMode.ToString(),
+                ["ambientIntensity"] = (double)RenderSettings.ambientIntensity,
+                ["fog"] = RenderSettings.fog,
+                ["fogMode"] = RenderSettings.fogMode.ToString(),
+                ["fogDensity"] = (double)RenderSettings.fogDensity,
+                ["fogStartDistance"] = (double)RenderSettings.fogStartDistance,
+                ["fogEndDistance"] = (double)RenderSettings.fogEndDistance,
+            };
+
+            var c = RenderSettings.ambientLight;
+            result["ambientColor"] = new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
+
+            var fc = RenderSettings.fogColor;
+            result["fogColor"] = new List<object> { (double)fc.r, (double)fc.g, (double)fc.b, (double)fc.a };
+
+            if (RenderSettings.skybox != null)
+                result["skybox"] = RenderSettings.skybox.name;
+
+            if (RenderSettings.sun != null)
+                result["sunSource"] = RenderSettings.sun.gameObject.name;
+
+            return result;
+        }
+
+        private static object HandleSetLightingSetting(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("key", out var keyObj))
+                throw new ArgumentException("Missing 'key' parameter");
+            if (!p.ContainsKey("value"))
+                throw new ArgumentException("Missing 'value' parameter");
+
+            string key = keyObj.ToString();
+            object value = p["value"];
+
+            switch (key)
+            {
+                case "ambientMode":
+                    if (Enum.TryParse<AmbientMode>(value.ToString(), out var am))
+                        RenderSettings.ambientMode = am;
+                    break;
+                case "ambientIntensity":
+                    RenderSettings.ambientIntensity = Convert.ToSingle(value);
+                    break;
+                case "ambientColor":
+                    if (value is List<object> ac && ac.Count >= 3)
+                        RenderSettings.ambientLight = new Color(
+                            Convert.ToSingle(ac[0]),
+                            Convert.ToSingle(ac[1]),
+                            Convert.ToSingle(ac[2]),
+                            ac.Count >= 4 ? Convert.ToSingle(ac[3]) : 1f);
+                    break;
+                case "fog":
+                    RenderSettings.fog = Convert.ToBoolean(value);
+                    break;
+                case "fogMode":
+                    if (Enum.TryParse<FogMode>(value.ToString(), out var fm))
+                        RenderSettings.fogMode = fm;
+                    break;
+                case "fogDensity":
+                    RenderSettings.fogDensity = Convert.ToSingle(value);
+                    break;
+                case "fogColor":
+                    if (value is List<object> fca && fca.Count >= 3)
+                        RenderSettings.fogColor = new Color(
+                            Convert.ToSingle(fca[0]),
+                            Convert.ToSingle(fca[1]),
+                            Convert.ToSingle(fca[2]),
+                            fca.Count >= 4 ? Convert.ToSingle(fca[3]) : 1f);
+                    break;
+                case "fogStartDistance":
+                    RenderSettings.fogStartDistance = Convert.ToSingle(value);
+                    break;
+                case "fogEndDistance":
+                    RenderSettings.fogEndDistance = Convert.ToSingle(value);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown lighting setting: {key}");
+            }
+
+            return new Dictionary<string, object> { ["status"] = "ok", ["key"] = key };
+        }
+
+        private static object HandleTagsAndLayers(string paramsJson)
+        {
+            var tags = new List<object>();
+            foreach (var tag in UnityEditorInternal.InternalEditorUtility.tags)
+                tags.Add(tag);
+
+            var layers = new List<object>();
+            for (int i = 0; i < 32; i++)
+            {
+                string name = LayerMask.LayerToName(i);
+                if (!string.IsNullOrEmpty(name))
+                {
+                    layers.Add(new Dictionary<string, object>
+                    {
+                        ["index"] = i,
+                        ["name"] = name
+                    });
+                }
+            }
+
+            var sortingLayers = new List<object>();
+            foreach (var sl in SortingLayer.layers)
+            {
+                sortingLayers.Add(new Dictionary<string, object>
+                {
+                    ["id"] = sl.id,
+                    ["name"] = sl.name,
+                    ["value"] = sl.value
+                });
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["tags"] = tags,
+                ["layers"] = layers,
+                ["sortingLayers"] = sortingLayers
+            };
+        }
+
+        private static object HandleAddTag(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("tag", out var tagObj))
+                throw new ArgumentException("Missing 'tag' parameter");
+
+            string tag = tagObj.ToString();
+
+            // Check if tag already exists
+            var so = new SerializedObject(
+                AssetDatabase.LoadMainAssetAtPath("ProjectSettings/TagManager.asset"));
+            var tagsProp = so.FindProperty("tags");
+
+            for (int i = 0; i < tagsProp.arraySize; i++)
+            {
+                if (tagsProp.GetArrayElementAtIndex(i).stringValue == tag)
+                    return new Dictionary<string, object>
+                    {
+                        ["status"] = "exists",
+                        ["tag"] = tag
+                    };
+            }
+
+            tagsProp.InsertArrayElementAtIndex(tagsProp.arraySize);
+            tagsProp.GetArrayElementAtIndex(tagsProp.arraySize - 1).stringValue = tag;
+            so.ApplyModifiedProperties();
+            so.Dispose();
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["tag"] = tag
+            };
+        }
+
+        private static object HandleAddLayer(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");
+
+            string layerName = nameObj.ToString();
+            int targetIndex = -1;
+            if (p.TryGetValue("index", out var idxObj))
+                targetIndex = Convert.ToInt32(idxObj);
+
+            var so = new SerializedObject(
+                AssetDatabase.LoadMainAssetAtPath("ProjectSettings/TagManager.asset"));
+            var layersProp = so.FindProperty("layers");
+
+            // Check if layer already exists
+            for (int i = 0; i < layersProp.arraySize; i++)
+            {
+                if (layersProp.GetArrayElementAtIndex(i).stringValue == layerName)
+                    return new Dictionary<string, object>
+                    {
+                        ["status"] = "exists",
+                        ["name"] = layerName,
+                        ["index"] = i
+                    };
+            }
+
+            // Find first empty user layer (8-31) or use specified index
+            int assignedIndex = -1;
+            if (targetIndex >= 8 && targetIndex < 32)
+            {
+                if (string.IsNullOrEmpty(layersProp.GetArrayElementAtIndex(targetIndex).stringValue))
+                {
+                    layersProp.GetArrayElementAtIndex(targetIndex).stringValue = layerName;
+                    assignedIndex = targetIndex;
+                }
+                else
+                {
+                    throw new ArgumentException($"Layer index {targetIndex} is already in use");
+                }
+            }
+            else
+            {
+                for (int i = 8; i < 32; i++)
+                {
+                    if (string.IsNullOrEmpty(layersProp.GetArrayElementAtIndex(i).stringValue))
+                    {
+                        layersProp.GetArrayElementAtIndex(i).stringValue = layerName;
+                        assignedIndex = i;
+                        break;
+                    }
+                }
+            }
+
+            if (assignedIndex < 0)
+                throw new InvalidOperationException("No empty layer slots available");
+
+            so.ApplyModifiedProperties();
+            so.Dispose();
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["name"] = layerName,
+                ["index"] = assignedIndex
+            };
+        }
+    }
+}

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

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

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

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class FileController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("file/read", HandleRead);
+            router.Register("file/write", HandleWrite);
+            router.Register("file/patch", HandlePatch);
+        }
+
+        private static string ProjectRoot =>
+            Path.GetDirectoryName(Application.dataPath);
+
+        private static string ResolveSafePath(string relativePath)
+        {
+            var projectRoot = ProjectRoot;
+            var fullPath = Path.GetFullPath(Path.Combine(projectRoot, relativePath));
+
+            // Security: ensure path is within project root
+            if (!fullPath.StartsWith(projectRoot, StringComparison.OrdinalIgnoreCase))
+                throw new UnauthorizedAccessException(
+                    $"Path escapes project root: {relativePath}");
+
+            return fullPath;
+        }
+
+        private static object HandleRead(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");
+
+            var fullPath = ResolveSafePath(pathObj.ToString());
+
+            if (!File.Exists(fullPath))
+                throw new FileNotFoundException($"File not found: {pathObj}");
+
+            var content = File.ReadAllText(fullPath);
+
+            return new Dictionary<string, object>
+            {
+                ["path"] = pathObj.ToString(),
+                ["content"] = content,
+                ["size"] = content.Length
+            };
+        }
+
+        private static object HandleWrite(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");
+            if (!p.TryGetValue("content", out var contentObj))
+                throw new ArgumentException("Missing 'content' parameter");
+            var noReimport = p.TryGetValue("noReimport", out var noReimportObj)
+                && noReimportObj != null
+                && Convert.ToBoolean(noReimportObj);
+
+            var fullPath = ResolveSafePath(pathObj.ToString());
+
+            // Create directory if needed
+            var dir = Path.GetDirectoryName(fullPath);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+                Directory.CreateDirectory(dir);
+
+            File.WriteAllText(fullPath, contentObj.ToString());
+            var reimport = AssetImportSupport.ReimportOrDescribe(pathObj.ToString(), noReimport);
+
+            return new Dictionary<string, object>
+            {
+                ["path"] = pathObj.ToString(),
+                ["written"] = true,
+                ["size"] = contentObj.ToString().Length,
+                ["reimport"] = reimport
+            };
+        }
+
+        private static object HandlePatch(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");
+            if (!p.TryGetValue("patch", out var patchObj))
+                throw new ArgumentException("Missing 'patch' parameter");
+            var noReimport = p.TryGetValue("noReimport", out var noReimportObj)
+                && noReimportObj != null
+                && Convert.ToBoolean(noReimportObj);
+
+            var fullPath = ResolveSafePath(pathObj.ToString());
+
+            if (!File.Exists(fullPath))
+                throw new FileNotFoundException($"File not found: {pathObj}");
+
+            var original = File.ReadAllText(fullPath);
+
+            // Support patch as either a dict with find/replace keys, or a JSON string
+            Dictionary<string, object> patchData = null;
+
+            if (patchObj is Dictionary<string, object> dict)
+            {
+                patchData = dict;
+            }
+            else
+            {
+                var patchContent = patchObj.ToString();
+                if (patchContent.TrimStart().StartsWith("{"))
+                    patchData = MiniJson.Deserialize(patchContent) as Dictionary<string, object>;
+            }
+
+            if (patchData != null &&
+                patchData.TryGetValue("find", out var findObj) &&
+                patchData.TryGetValue("replace", out var replaceObj))
+            {
+                var find = findObj.ToString();
+                var replace = replaceObj.ToString();
+                if (!original.Contains(find))
+                    throw new Exception("Patch target not found in file");
+
+                var patched = original.Replace(find, replace);
+                File.WriteAllText(fullPath, patched);
+                var reimport = AssetImportSupport.ReimportOrDescribe(pathObj.ToString(), noReimport);
+
+                return new Dictionary<string, object>
+                {
+                    ["path"] = pathObj.ToString(),
+                    ["patched"] = true,
+                    ["reimport"] = reimport
+                };
+            }
+
+            throw new ArgumentException("Unsupported patch format. Use {\"find\": \"...\", \"replace\": \"...\"}");
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2183be6281cf441469323bee5c73467b