com.robotsquid.squidhub 0.5.5 → 0.5.7

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## 0.5.7
+
+**The manifest is a form now, and a build can go out in one action.**
+
+`SquidHub → Game Manifest…` edits `manifest.json` beside `Assets/` — id, title,
+capabilities, save schema, orientations, aspect window, sound. It is the same
+file `squidhub-release` reads, so the Editor and the CLI cannot disagree about
+what a game declares.
+
+`SquidHub → Build and Upload…` picks a build profile, builds it, and uploads the
+result through the same refusals a hand-picked folder goes through.
+
+**The post-build step now writes `manifest.json` into the output.** Without it a
+build declares nothing — the server reads the manifest out of the uploaded bytes
+and ignores anything posted alongside the upload, so every Unity build made
+before this one carried save schema 1 and no display constraints regardless of
+what the project's manifest said.
+
+⚠️ **"Publish the build" is ticked by default and works on DEV ONLY.** On prod
+the server refuses a key-authorised publish and the Editor says so; the upload
+still succeeds and the build arrives registered, not live. Promoting a build for
+every player is an owner decision made by a person in the console — an upload
+key lives in CI configs and Editor preferences, and letting one promote on prod
+would mean a leaked key can replace the live build for everyone. `keyMayPublish`
+is an allowlist, so an environment invented later is refused by default rather
+than inheriting the dangerous answer.
+
+⚠️ **The manifest editor preserves keys it does not model.** `skus`,
+`achievements` and `rewardTable` survive a save untouched. Round-tripping
+through a typed model would have deleted a publisher's catalogue declaration and
+they would have found out one release later.
+
+⚠️ **A capability tick is a declaration, not a grant.** The dialog says so beside
+the boxes that need review.
+
+## 0.5.6
+
+⚠️ **Fixes an upload that did nothing and said nothing.** `SquidHub → Upload
+Build…` in 0.5.5 ran, reported no error, and uploaded no files.
+
+`yield return SomeOtherIEnumerator()` requires the coroutine driver to DESCEND
+into the nested routine. Unity's own runner does; the hand-rolled one here did
+not — it treated the nested iterator as an ordinary yielded value, discarded it,
+and carried on. So the request that starts a build never executed, the response
+stayed null, and the routine exited quietly on a null check.
+
+The driver is now `SquidHubPump`, which has no `UnityEditor` dependency and is
+unit-tested for exactly that nesting rule, three levels deep. The JSON field
+reader moved into the tested file too, since a null that looks like an answer is
+the same failure in a different costume, and the run now logs what it is doing
+so a silent no-op cannot recur.
+
 ## 0.5.5
 
 **Upload a build straight from Unity.** `SquidHub → Upload Build…` picks the

package/Editor/SquidHubBuildProcessor.cs

@@ -83,12 +83,48 @@ namespace SquidHub.Editor
             File.WriteAllText(indexPath, result.Html);
             foreach (var note in result.Notes) log.Append("  ✓ ").Append(note).Append('\n');
 
+            WriteManifest(outDir, log);
+
             log.Append("\nPush it with:\n  node src/cli.mjs push --game <slug> --dir ")
                .Append(outDir).Append(" --env=dev --verify");
 
             Debug.Log(log.ToString());
         }
 
+        /// <summary>
+        /// Writes the game's declaration into the build.
+        ///
+        /// ⚠️ Without this file the build declares NOTHING. The server reads
+        /// `manifest.json` out of the uploaded bytes — never from anything the
+        /// client posts alongside the upload — so an absent manifest means the
+        /// default everything: save schema 1, no display constraints, and a
+        /// rollback guard that cannot fire.
+        ///
+        /// ⚠️ A WARNING, not a build failure. A publisher mid-setup has no
+        /// manifest yet and their build is still perfectly runnable; refusing it
+        /// would make the package harder to adopt than to ignore. An
+        /// UNREADABLE or INVALID manifest is louder, because that one is a file
+        /// they wrote and believe is in effect.
+        /// </summary>
+        private static void WriteManifest(string outDir, StringBuilder log)
+        {
+            if (!File.Exists(SquidHubUploadSettings.ManifestPath))
+            {
+                log.Append("  · no manifest.json — this build declares nothing. " +
+                           "Set one up in SquidHub → Game Manifest…\n");
+                return;
+            }
+
+            if (!SquidHubManifestWindow.WriteInto(outDir, out var problem))
+            {
+                Debug.LogError("SquidHub: manifest.json was NOT written into the build, so it " +
+                               "declares nothing:\n" + problem);
+                return;
+            }
+
+            log.Append("  ✓ wrote manifest.json\n");
+        }
+
         private static bool InstallBridge(string outDir, StringBuilder log)
         {
             var source = SquidHubPackage.FindBridge();

package/Editor/SquidHubBuildScan.cs

@@ -141,6 +141,29 @@ namespace SquidHub.Editor
             return "[" + string.Join(",", parts) + "]";
         }
 
+        /// <summary>
+        /// Reads one flat field out of a JSON response.
+        ///
+        /// ⚠️ A regex, not a parser, and deliberately only for the handful of
+        /// flat fields this flow reads. Shipping a parser in a package that
+        /// already asks the project to bring its own would be a second, worse
+        /// one to maintain.
+        ///
+        /// ⚠️ Returns null when absent, and the caller must treat that as a
+        /// failure rather than a value. Every silent no-op in this uploader has
+        /// come from a null that looked like an answer.
+        /// </summary>
+        public static string JsonField(string json, string name)
+        {
+            if (string.IsNullOrEmpty(json)) return null;
+            var match = System.Text.RegularExpressions.Regex.Match(
+                json,
+                "\"" + System.Text.RegularExpressions.Regex.Escape(name) +
+                    "\"\\s*:\\s*(?:\"([^\"]*)\"|(true|false|-?[0-9.]+))");
+            if (!match.Success) return null;
+            return match.Groups[1].Success ? match.Groups[1].Value : match.Groups[2].Value;
+        }
+
         internal static string JsonString(string value)
         {
             var sb = new System.Text.StringBuilder("\"");

package/Editor/SquidHubBuildWindow.cs

@@ -0,0 +1,291 @@
+// SquidHub → Build and Upload… — pick a build profile, build, upload, publish.
+//
+// ⚠️ Build profiles are a Unity 6 feature and this package supports 2021.3, so
+// everything that touches `UnityEditor.Build.Profile` is behind a version
+// guard. On an older Editor the window still uploads; it just cannot build.
+//
+// ⚠️ It uploads THE FOLDER IT JUST BUILT, through the same
+// `SquidHubUploader.Begin` a hand-picked folder goes through. One set of
+// refusals, so a build made here cannot bypass a check a manual upload applies.
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+#if UNITY_6000_0_OR_NEWER
+using UnityEditor.Build.Profile;
+#endif
+
+namespace SquidHub.Editor
+{
+    internal sealed class SquidHubBuildWindow : EditorWindow
+    {
+        private Vector2 _scroll;
+
+#if UNITY_6000_0_OR_NEWER
+        private BuildProfile[] _profiles = new BuildProfile[0];
+        private string[] _names = new string[0];
+        private int _selected = -1;
+#endif
+
+        [MenuItem("SquidHub/Build and Upload…", priority = 12)]
+        private static void Open()
+        {
+            var window = GetWindow<SquidHubBuildWindow>(true, "SquidHub Build and Upload", true);
+            window.minSize = new Vector2(520, 400);
+            window.Refresh();
+        }
+
+        private void Refresh()
+        {
+#if UNITY_6000_0_OR_NEWER
+            // ⚠️ AssetDatabase, not BuildProfile's own enumerator. This is the
+            // public, version-stable way to find them, and it also picks up a
+            // profile created since the window was opened.
+            _profiles = AssetDatabase.FindAssets("t:BuildProfile")
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .OrderBy(path => path)
+                .Select(AssetDatabase.LoadAssetAtPath<BuildProfile>)
+                .Where(profile => profile != null)
+                .ToArray();
+
+            _names = _profiles.Select(p => AssetDatabase.GetAssetPath(p)).ToArray();
+
+            var remembered = SquidHubUploadSettings.BuildProfilePath;
+            _selected = System.Array.IndexOf(_names, remembered);
+
+            // Fall back to whatever the Editor itself is set to build.
+            if (_selected < 0)
+            {
+                var active = BuildProfile.GetActiveBuildProfile();
+                if (active != null)
+                    _selected = System.Array.IndexOf(_names, AssetDatabase.GetAssetPath(active));
+            }
+            if (_selected < 0 && _profiles.Length > 0) _selected = 0;
+#endif
+        }
+
+        private void OnGUI()
+        {
+            _scroll = EditorGUILayout.BeginScrollView(_scroll);
+
+            DrawProfile();
+            EditorGUILayout.Space();
+            DrawOutput();
+            EditorGUILayout.Space();
+            DrawPublish();
+            EditorGUILayout.Space();
+            DrawManifestSummary();
+
+            EditorGUILayout.EndScrollView();
+            EditorGUILayout.Space();
+            DrawButtons();
+        }
+
+        private void DrawProfile()
+        {
+            EditorGUILayout.LabelField("Build profile", EditorStyles.boldLabel);
+#if UNITY_6000_0_OR_NEWER
+            if (_profiles.Length == 0)
+            {
+                EditorGUILayout.HelpBox(
+                    "No build profiles in this project. Create one in File → Build Profiles, " +
+                    "targeting Web, then reopen this window.",
+                    MessageType.Warning);
+                if (GUILayout.Button("Refresh")) Refresh();
+                return;
+            }
+
+            var chosen = EditorGUILayout.Popup("Profile", Mathf.Max(0, _selected), _names);
+            if (chosen != _selected)
+            {
+                _selected = chosen;
+                SquidHubUploadSettings.BuildProfilePath = _names[_selected];
+            }
+
+            // ⚠️ The profile's target is not checked here — there is no stable
+            // public accessor for it — so it is checked after the build from the
+            // BuildReport, which is authoritative. A non-Web profile builds and
+            // is then refused, rather than uploading something no browser runs.
+            EditorGUILayout.HelpBox(
+                "The profile must target Web. A build for any other platform is refused after " +
+                "building rather than uploaded.",
+                MessageType.None);
+
+            if (GUILayout.Button("Refresh list")) Refresh();
+#else
+            EditorGUILayout.HelpBox(
+                "Build profiles need Unity 6. On this Editor, build with File → Build Settings " +
+                "and then use Upload, or SquidHub → Upload Build….",
+                MessageType.Info);
+#endif
+        }
+
+        private void DrawOutput()
+        {
+            EditorGUILayout.LabelField("Output folder", EditorStyles.boldLabel);
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.SelectableLabel(
+                    string.IsNullOrEmpty(SquidHubUploadSettings.BuildFolder)
+                        ? "(none chosen)"
+                        : SquidHubUploadSettings.BuildFolder,
+                    EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
+
+                if (GUILayout.Button("Choose…", GUILayout.Width(90)))
+                {
+                    var start = SquidHubUploadSettings.BuildFolder;
+                    var folder = EditorUtility.SaveFolderPanel(
+                        "Build into", string.IsNullOrEmpty(start) ? "" : start, "web");
+                    if (!string.IsNullOrEmpty(folder)) SquidHubUploadSettings.BuildFolder = folder;
+                }
+            }
+        }
+
+        private void DrawPublish()
+        {
+            EditorGUILayout.LabelField("On a successful upload", EditorStyles.boldLabel);
+
+            SquidHubUploadSettings.PublishAfterUpload = EditorGUILayout.ToggleLeft(
+                new GUIContent("Publish the build",
+                    "Makes the build live for players. The server allows this on dev only."),
+                SquidHubUploadSettings.PublishAfterUpload);
+
+            if (SquidHubUploadSettings.PublishAfterUpload)
+            {
+                // ⚠️ Stated plainly rather than left to be discovered. The tick is
+                // on by default and does nothing on prod, and a publisher who
+                // believes otherwise ships a build they think is live.
+                EditorGUILayout.HelpBox(
+                    "This works on dev only. On prod the server refuses it — promoting a build " +
+                    "for every player is an owner decision made in the console, and an upload key " +
+                    "is not a person. The upload still succeeds; you will be told it was not published.",
+                    MessageType.Info);
+            }
+
+            EditorGUILayout.LabelField("Console", SquidHubUploadSettings.Endpoint, EditorStyles.miniLabel);
+        }
+
+        private void DrawManifestSummary()
+        {
+            EditorGUILayout.LabelField("Declaration", EditorStyles.boldLabel);
+
+            if (!File.Exists(SquidHubUploadSettings.ManifestPath))
+            {
+                EditorGUILayout.HelpBox(
+                    "No manifest.json, so this build will declare nothing: save schema 1 and no " +
+                    "display constraints.",
+                    MessageType.Warning);
+            }
+            else
+            {
+                try
+                {
+                    var manifest = SquidHubManifest.Load(SquidHubUploadSettings.ManifestPath);
+                    var errors = manifest.Errors();
+                    if (errors.Count > 0)
+                    {
+                        EditorGUILayout.HelpBox(
+                            "manifest.json is not valid, and the build will not carry it:\n\n" +
+                            string.Join("\n", errors),
+                            MessageType.Error);
+                    }
+                    else
+                    {
+                        EditorGUILayout.LabelField(
+                            manifest.GameId + "  ·  save schema " + manifest.SaveSchemaVersion +
+                            "  ·  " + string.Join(", ", manifest.Capabilities),
+                            EditorStyles.miniLabel);
+                    }
+                }
+                catch (System.Exception e)
+                {
+                    EditorGUILayout.HelpBox("manifest.json could not be read: " + e.Message, MessageType.Error);
+                }
+            }
+
+            if (GUILayout.Button("Edit manifest…")) SquidHubManifestWindow.Open();
+        }
+
+        private void DrawButtons()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+#if UNITY_6000_0_OR_NEWER
+                using (new EditorGUI.DisabledScope(_profiles.Length == 0 || _selected < 0))
+                {
+                    if (GUILayout.Button("Build and Upload", GUILayout.Height(28))) BuildThenUpload();
+                    if (GUILayout.Button("Build only", GUILayout.Height(28))) Build();
+                }
+#endif
+                if (GUILayout.Button("Upload only", GUILayout.Height(28)))
+                {
+                    var folder = SquidHubUploadSettings.BuildFolder;
+                    if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
+                        EditorUtility.DisplayDialog("SquidHub", "Choose an output folder first.", "OK");
+                    else
+                        SquidHubUploader.Begin(folder);
+                }
+            }
+        }
+
+#if UNITY_6000_0_OR_NEWER
+        private void BuildThenUpload()
+        {
+            // ⚠️ The key is checked BEFORE building. Discovering there is no key
+            // after a twenty-minute WebGL build is the kind of thing that makes
+            // people go back to the command line.
+            if (!SquidHubUploader.EnsureKey()) return;
+
+            var folder = Build();
+            if (folder != null) SquidHubUploader.Begin(folder);
+        }
+
+        /// <summary>The folder that was built into, or null when the build did not produce one.</summary>
+        private string Build()
+        {
+            var folder = SquidHubUploadSettings.BuildFolder;
+            if (string.IsNullOrEmpty(folder))
+            {
+                EditorUtility.DisplayDialog("SquidHub", "Choose an output folder first.", "OK");
+                return null;
+            }
+
+            var profile = _profiles[_selected];
+
+            // ⚠️ Made active first. A profile passed only to BuildPlayer leaves
+            // the Editor's own target where it was, and the next manual build
+            // from File → Build silently uses a different one.
+            BuildProfile.SetActiveBuildProfile(profile);
+
+            var report = BuildPipeline.BuildPlayer(new BuildPlayerWithProfileOptions
+            {
+                buildProfile = profile,
+                locationPathName = folder,
+                options = BuildOptions.None,
+            });
+
+            if (report == null || report.summary.result != BuildResult.Succeeded)
+            {
+                // ⚠️ No dialog. A failed build has already filled the Console with
+                // the reason, and a modal saying "it failed" on top of that just
+                // has to be dismissed before anyone can read it.
+                Debug.LogError("[SquidHub] the build did not succeed — nothing was uploaded.");
+                return null;
+            }
+
+            if (report.summary.platform != BuildTarget.WebGL)
+            {
+                EditorUtility.DisplayDialog("SquidHub",
+                    "That profile built for " + report.summary.platform + ", not Web.\n\n" +
+                    "SquidHub serves WebGL builds, and the bridge was not installed into this one. " +
+                    "Point the profile at the Web platform and build again.",
+                    "OK");
+                return null;
+            }
+
+            return folder;
+        }
+#endif
+    }
+}

package/Editor/SquidHubBuildWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c05e02aea772f507162356a3628335ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: