com.robotsquid.squidhub 0.5.6 → 0.5.8

package/Editor/SquidHubUploadSettings.cs

@@ -36,7 +36,47 @@ namespace SquidHub.Editor
             set => EditorPrefs.SetString(Scope + "buildFolder", value);
         }
 
+        /// <summary>
+        /// The build profile `Build and Upload` uses, as an asset path.
+        ///
+        /// ⚠️ A PATH, not a cached object reference. EditorPrefs cannot hold one,
+        /// and a GUID would survive the profile being deleted as a dangling id
+        /// that resolves to nothing with no way to say what is missing.
+        /// </summary>
+        public static string BuildProfilePath
+        {
+            get => EditorPrefs.GetString(Scope + "buildProfile", "");
+            set => EditorPrefs.SetString(Scope + "buildProfile", value ?? "");
+        }
+
+        /// <summary>
+        /// Publish the build to players the moment it uploads.
+        ///
+        /// ⚠️ ON by default, and it only ever applies on the DEV environment.
+        /// The server refuses a key-authorised publish on prod — promoting a
+        /// build for every player is an owner decision made in the console, and
+        /// an upload key is not a person. See `setChannelWithKey`.
+        /// </summary>
+        public static bool PublishAfterUpload
+        {
+            get => EditorPrefs.GetBool(Scope + "publishAfterUpload", true);
+            set => EditorPrefs.SetBool(Scope + "publishAfterUpload", value);
+        }
+
         public static bool HasKey => Key.StartsWith("shu_");
+
+        /// <summary>
+        /// `manifest.json` beside `Assets/`, which is what `squidhub-release
+        /// build --manifest manifest.json` already reads.
+        ///
+        /// ⚠️ ONE source of truth, deliberately. Keeping the declaration in a
+        /// Unity-only asset would give the Editor and the CLI two answers to
+        /// "what does this game declare", and they would disagree on the day it
+        /// mattered. It is a normal project file and belongs in the repository.
+        /// </summary>
+        public static string ManifestPath =>
+            System.IO.Path.Combine(
+                System.IO.Path.GetDirectoryName(Application.dataPath) ?? "", "manifest.json");
     }
 
     internal sealed class SquidHubUploadSettingsWindow : EditorWindow

package/Editor/SquidHubUploader.cs

@@ -11,6 +11,7 @@
 using System;
 using System.Collections;
 using System.IO;
+using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using UnityEditor;
@@ -26,20 +27,39 @@ namespace SquidHub.Editor
         [MenuItem("SquidHub/Upload Build…", priority = 11)]
         private static void UploadBuild()
         {
-            if (!SquidHubUploadSettings.HasKey)
-            {
-                EditorUtility.DisplayDialog("SquidHub",
-                    "No upload key set. Create one in the publisher console under your game → " +
-                    "Upload keys, then paste it into SquidHub → Upload Settings.", "OK");
-                SquidHubUploadSettingsWindow.GetWindow<SquidHubUploadSettingsWindow>();
-                return;
-            }
+            if (!EnsureKey()) return;
 
             var start = SquidHubUploadSettings.BuildFolder;
             var folder = EditorUtility.OpenFolderPanel(
                 "Select the WebGL build folder (containing index.html)",
                 string.IsNullOrEmpty(start) ? "" : start, "");
             if (string.IsNullOrEmpty(folder)) return;
+
+            Begin(folder);
+        }
+
+        /// <summary>Nothing can proceed without a key, and saying so early costs nothing.</summary>
+        internal static bool EnsureKey()
+        {
+            if (SquidHubUploadSettings.HasKey) return true;
+
+            EditorUtility.DisplayDialog("SquidHub",
+                "No upload key set. Create one in the publisher console under your game → " +
+                "Upload keys, then paste it into SquidHub → Upload Settings.", "OK");
+            SquidHubUploadSettingsWindow.GetWindow<SquidHubUploadSettingsWindow>();
+            return false;
+        }
+
+        /// <summary>
+        /// Scans a build folder, confirms, and uploads it.
+        ///
+        /// ⚠️ The entry point `Build and Upload` uses too, so a build made here
+        /// and a folder picked by hand go through exactly the same refusals.
+        /// </summary>
+        internal static void Begin(string folder)
+        {
+            if (!EnsureKey()) return;
+
             SquidHubUploadSettings.BuildFolder = folder;
 
             BuildScan scan;
@@ -63,17 +83,34 @@ namespace SquidHub.Editor
                 return;
             }
 
+            var publish = SquidHubUploadSettings.PublishAfterUpload;
+
             if (!EditorUtility.DisplayDialog("SquidHub",
                     $"Upload {scan.Files.Count} files ({scan.TotalBytes / 1024f / 1024f:F1} MB)?" +
                     (scan.Skipped.Count > 0
                         ? $"\n\n{scan.Skipped.Count} OS metadata file(s) will be skipped."
+                        : "") +
+                    // ⚠️ Said before the upload, not after. A build folder with no
+                    // manifest.json declares nothing — save schema 1, no display
+                    // constraints — and the publisher cannot tell from the result.
+                    (scan.Files.Any(f => f.Path == "manifest.json")
+                        ? ""
+                        : "\n\nThere is no manifest.json in this folder, so the build declares " +
+                          "nothing: save schema 1 and no display constraints. Set one up in " +
+                          "SquidHub → Game Manifest… and rebuild.") +
+                    // ⚠️ These describe a build that uploads fine and PLAYS badly,
+                    // which is the kind nobody catches until a player does.
+                    (scan.Warnings.Count > 0 ? "\n\n" + string.Join("\n\n", scan.Warnings) : "") +
+                    (publish
+                        ? "\n\nIt will be published to players if the server allows it — that is " +
+                          "dev only. On prod, promote it in the console."
                         : ""),
                     "Upload", "Cancel"))
             {
                 return;
             }
 
-            Run(Upload(scan));
+            Run(Upload(scan, publish));
         }
 
         // ⚠️ Driven by EditorApplication.update rather than blocking. Sleeping
@@ -109,7 +146,7 @@ namespace SquidHub.Editor
             Debug.Log("[SquidHub] upload run finished.");
         }
 
-        private static IEnumerator Upload(BuildScan scan)
+        private static IEnumerator Upload(BuildScan scan, bool publish)
         {
             var endpoint = SquidHubUploadSettings.Endpoint;
             var key = SquidHubUploadSettings.Key;
@@ -187,12 +224,98 @@ namespace SquidHub.Editor
                 yield break;
             }
 
-            // ⚠️ Registered, NOT live. Promoting a build to players is a separate,
-            // deliberate act in the console — saying "uploaded" without saying
-            // that invites someone to assume their players already have it.
-            EditorUtility.DisplayDialog("SquidHub",
-                "Registered " + SquidHubBuildScan.JsonField(doneResponse, "buildHash") + ".\n\n" +
-                "It is not live yet — promote it in the publisher console when you are ready.",
+            var buildHash = SquidHubBuildScan.JsonField(doneResponse, "buildHash");
+
+            // ⚠️ Surfaced, not swallowed. The server warns rather than fails when
+            // a manifest change had no effect, and that warning is the only thing
+            // standing between a publisher and believing their edit shipped.
+            var warning = SquidHubBuildScan.JsonField(doneResponse, "detail");
+            if (warning != null) Debug.LogWarning("[SquidHub] " + warning);
+
+            if (!publish)
+            {
+                // ⚠️ Registered, NOT live. Promoting a build to players is a
+                // separate, deliberate act — saying "uploaded" without saying
+                // that invites someone to assume their players already have it.
+                EditorUtility.DisplayDialog("SquidHub",
+                    "Registered " + buildHash + ".\n\n" +
+                    "It is not live yet — promote it in the publisher console when you are ready.",
+                    "OK");
+                yield break;
+            }
+
+            yield return PublishStep(endpoint, key, buildHash);
+        }
+
+        /// <summary>
+        /// Asks the server to make the build live.
+        ///
+        /// ⚠️ THE SERVER DECIDES, and it refuses on prod. An upload key lives in
+        /// CI configs and Editor preferences; promoting a build for every player
+        /// is an owner decision made by a person in the console. A refusal here
+        /// is the system working, so it reports as information rather than as a
+        /// failure — the upload really did succeed.
+        /// </summary>
+        private static IEnumerator PublishStep(string endpoint, string key, string buildHash)
+        {
+            if (string.IsNullOrEmpty(buildHash))
+            {
+                Debug.LogError("[SquidHub] the server registered the build but named no buildHash, " +
+                               "so it cannot be published. It is uploaded; promote it in the console.");
+                yield break;
+            }
+
+            EditorUtility.DisplayProgressBar("SquidHub", "Publishing…", 0.995f);
+
+            string response = null;
+            yield return Post(endpoint + "/api/ingest",
+                key,
+                "{\"intent\":\"publish\",\"buildHash\":" + SquidHubBuildScan.JsonString(buildHash) + "}",
+                r => response = r);
+
+            EditorUtility.ClearProgressBar();
+
+            // ⚠️ Post already reported the failure. Reaching here with null means
+            // the publish did not happen, and the build IS still uploaded — which
+            // is the one thing the publisher needs to be told.
+            if (response == null)
+            {
+                Debug.LogWarning("[SquidHub] " + buildHash + " is uploaded but was NOT published.");
+                yield break;
+            }
+
+            if (SquidHubBuildScan.JsonField(response, "ok") == "true")
+            {
+                var stranded = SquidHubBuildScan.JsonField(response, "strandedPlayers");
+                Debug.Log("[SquidHub] published " + buildHash + ".");
+                EditorUtility.DisplayDialog("SquidHub",
+                    "Published " + buildHash + ". Players get it on their next launch." +
+                    (stranded != null && stranded != "0"
+                        ? "\n\n⚠️ " + stranded + " player(s) have a save this build's schema cannot read."
+                        : ""),
+                    "OK");
+                yield break;
+            }
+
+            var code = SquidHubBuildScan.JsonField(response, "code");
+            var message = SquidHubBuildScan.JsonField(response, "message") ?? response;
+
+            if (code == "MANUAL_ON_PROD")
+            {
+                Debug.Log("[SquidHub] uploaded " + buildHash + "; publishing on prod is manual.");
+                EditorUtility.DisplayDialog("SquidHub",
+                    "Uploaded " + buildHash + ".\n\n" +
+                    "It was not published: an upload key can publish on dev, never on prod. " +
+                    "Promote it in the publisher console when you are ready.",
+                    "OK");
+                yield break;
+            }
+
+            Debug.LogWarning("[SquidHub] uploaded " + buildHash + " but the publish was refused: " +
+                             code + ": " + message);
+            EditorUtility.DisplayDialog("SquidHub — uploaded, not published",
+                "The build uploaded and is registered as " + buildHash + ", but publishing it was " +
+                "refused:\n\n" + message + "\n\nPromote it in the publisher console.",
                 "OK");
         }
 

package/README.md

@@ -68,6 +68,8 @@ Nothing to configure. On a WebGL build this package:
 2. **Writes `squidhub-bridge.js`** into the output and injects it ahead of the
    Unity loader.
 3. **Hoists every inline `<script>`** out of `index.html` into an external file.
+4. **Makes the game fill the frame** and hides Unity's own logo bar, build title
+   and fullscreen button.
 
 Step 3 is the one that matters. `squidhub-gamehost` serves
 `script-src 'self' 'wasm-unsafe-eval' blob:` with **no `'unsafe-inline'`**, and
@@ -76,29 +78,71 @@ all the markup is there, and nothing runs — the only signal is a CSP violation
 in the console. This is the single most common first-integration failure, and
 you should never see it.
 
+⚠️ **Step 4 is why your game is not a 960×600 box in the corner.** The portal
+already letterboxes — it measures its box, clamps it to the aspect window you
+declared and hands the frame an element of exactly that size. Unity's stock
+template then renders a fixed 960×600 centred inside *that*, on a white page,
+under a Unity logo and a second fullscreen button that fights the portal's own.
+The footer is hidden rather than removed, because the stock bootstrap queries
+the fullscreen button and throws on null — which surfaces as an `alert()` where
+the game should be. Your loading bar is left alone: the portal draws none, so it
+is the only progress a player sees.
+
 Then push the folder:
 
 ```sh
 node src/cli.mjs push --game <slug> --dir <BuildFolder> --env=dev --verify
 ```
 
+## Declaring what your game is
+
+`SquidHub → Game Manifest…` edits `manifest.json` beside `Assets/` — the game's
+id and title, which capabilities it uses, its save schema version, the
+orientations and aspect window it wants, and whether it makes sound.
+
+It is the same file `squidhub-release build --manifest manifest.json` reads, so
+the Editor and the CLI cannot disagree about what your game declares. It belongs
+in your repository.
+
+The build writes it into the output folder for you. **That is the only thing
+that makes a declaration take effect** — the server reads `manifest.json` out of
+the uploaded bytes and ignores anything a client posts alongside the upload, so
+a build folder without one declares nothing at all: save schema 1, no display
+constraints, and a rollback guard that cannot fire.
+
+⚠️ **Ticking a capability does not grant it.** Capabilities are granted by the
+platform at review. Declaring `commerce.spend` says your game uses it; until it
+is granted the broker still answers `DENIED`, and your game has to handle that.
+New games have `saves` and `analytics`.
+
+⚠️ **Keys the dialog does not model are preserved.** `skus`, `achievements` and
+`rewardTable` live in the same file and survive a save untouched.
+
 ## Uploading from Unity
 
 `SquidHub → Upload Build…` does the whole publish — no console, no command line,
-no repository checkout.
+no repository checkout. `SquidHub → Build and Upload…` picks a **build profile**,
+builds it and uploads the result in one action.
 
 **Once:** in the publisher console open your game → **Upload keys** → create one,
 then paste it into `SquidHub → Upload Settings`.
 
 ⚠️ **The key never enters your project.** It lives in EditorPrefs, per machine
-and per project path, so it cannot reach your repository. It can do exactly one
-thing: upload a build for the one game it was minted for — it cannot read
-anything, publish to a channel, or touch another game. If it leaks, revoke it in
-the console; the worst it could have done is leave an unwanted build somewhere
-no player can see.
+and per project path, so it cannot reach your repository. It can upload a build
+for the one game it was minted for, and on **dev** publish that build — it
+cannot read anything, touch another game, or publish on prod. If it leaks,
+revoke it in the console.
+
+### Publishing on upload
+
+**Publish the build** is ticked by default in `SquidHub → Build and Upload…`.
 
-⚠️ **Uploading is not publishing.** The build arrives registered and not live.
-Promoting it to players stays a deliberate act in the console.
+⚠️ **It works on dev only.** On prod the server refuses it and says so; the
+upload still succeeds and the build arrives registered and not live. Promoting a
+build for every player is an owner decision made by a person in the console, and
+an upload key is not a person — it sits in CI configs and Editor preferences.
+That asymmetry is deliberate: it is what keeps a leaked key from replacing the
+live build for everyone.
 
 The upload is refused before a byte moves if the build is precompressed or has
 no `index.html` at its top level, and OS metadata is dropped rather than sent —
@@ -141,19 +185,20 @@ blocked at load and shows up as a console error, not as a missing style.
 Everything must ship inside the build.
 
 ⚠️ **Do not write your own rotate prompt or call `screen.orientation.lock()`.**
-Declare the orientations you support in your `manifest.json` and the portal
-draws the prompt outside your frame. Two prompts fight, and yours is the one the
+Declare the orientations you support in `SquidHub → Game Manifest…` and the
+portal draws the prompt outside your frame. Two prompts fight, and yours is the one the
 player sees first.
 
 ⚠️ **The mute button is the portal's, but the muting happens in your frame.** A
 cross-origin iframe has no `muted` property, so the SDK interposes a gain node
 on your `AudioContext`. It works without you doing anything — but only because
 the bridge is injected ahead of the loader, which is why step 2 above is not
-merely tidy. Declare `"sound": true` in your manifest or no button appears.
+merely tidy. Tick **Sound** in `SquidHub → Game Manifest…` or no button appears.
 
 ⚠️ **Editing `manifest.json` alone changes nothing.** It is excluded from the
 build hash, so a manifest-only re-upload registers no new version and your edit
-is discarded. Change a real file and rebuild.
+is discarded — the server now says so in a warning rather than staying silent.
+Change a real file and rebuild, or set an override in the console.
 
 ## ⚠️ Status
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.robotsquid.squidhub",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "displayName": "SquidHub",
   "description": "Cloud saves, analytics and the coin economy for Unity WebGL games published on SquidHub. Installs the C# wrapper, the .jslib half and the page bridge, and rewrites the exported index.html so it survives the platform's CSP.",
   "unity": "2021.3",