arcadible 1.0.9 → 1.0.11

package/bin/arc-deploy.js

@@ -136,14 +136,6 @@ const report = function (
 
 // [function]
 
-// the account, or null when there's none or it can't be refreshed: for a git
-// deploy, which needs none.
-const whoamiIfAny = function (opts) {
-  return whoami(opts).catch(() => null);
-};
-
-// [function]
-
 // the release, as `--json` prints it.
 const releaseJson = function (row) {
   if (!row) {
@@ -168,7 +160,7 @@ const waitAndReport = async function (
   current,
   deployed,
   result,
-  { git, json, owner, quiet, root, since, timeout },
+  { git, json, quiet, root, since, timeout },
 ) {
   let sw = new SpinnerWheel(phrase.releaseWaiting(git));
   sw.start(json || quiet);
@@ -178,7 +170,7 @@ const waitAndReport = async function (
     waited = await wait(
       current,
       deployed,
-      { git, owner, root, since, timeout },
+      { git, root, since, timeout },
       {
         onRelease() {
           // found: GitHub Actions is done, and Arcadible publishes it now.
@@ -253,9 +245,6 @@ const start = function (argv) {
   const timeout = Number(argv.timeout ?? TIMEOUT[git ? "git" : "direct"]);
   const root = resolve(process.cwd(), argv.cwd);
   let pb = null;
-  // the game's account, when Arcadible could say: a git deploy's owner waits
-  // among their own releases.
-  let owner = null;
   // whether the handle rules held the handle back from this release, so the
   // game's links are by id.
   let held = false;
@@ -277,14 +266,12 @@ const start = function (argv) {
       sw.stop(true);
       warn(warnings, { json, quiet });
       sw = new SpinnerWheel("Checking… %s");
-      // git deploys need no login: anyone who can push to the repository can
-      // release, and the Arcadible GitHub App publishes the release. Anyone
-      // can wait for it too; the game's owner, logged in, waits among their
-      // own releases, which also say when the repository isn't connected.
+      // git deploys need no login, and never use one: anyone who can push to
+      // the repository can release, and the Arcadible GitHub App publishes
+      // the release. Every call is public, so it's the same for whoever runs
+      // it, and the saved session isn't read, or refreshed.
       if (git) {
-        return whoamiIfAny({
-          handler: handler({ json, pb, quiet, sw, warnings }),
-        });
+        return null;
       }
       return whoami({ handler: handler({ json, pb, quiet, sw, warnings }) });
     })
@@ -309,7 +296,6 @@ const start = function (argv) {
     })
     .then(([current, predeployed]) => {
       sw.stop(true);
-      owner = predeployed.owner ?? null;
       held = predeployed.held ?? false;
       sw = new SpinnerWheel("Building… %s");
       sw.start(git || json || quiet);
@@ -394,7 +380,6 @@ const start = function (argv) {
         return waitAndReport(current, deployed, result, {
           git,
           json,
-          owner,
           quiet,
           root,
           since,

package/package.json

@@ -65,5 +65,5 @@
   "scripts": {
     "test": "node --test \"test/**/*.test.js\""
   },
-  "version": "1.0.9"
+  "version": "1.0.11"
 }

package/src/action/deploy/wait.js

@@ -63,27 +63,24 @@ const findDirect = function (id, headers) {
 // [function]
 
 // a git deploy's release: GitHub's, for this version, made since the tag was
-// pushed. Null until GitHub Actions has built it. The game's owner looks
-// among their account's releases, which include one with no game: a
-// repository that isn't connected fails that way (repo_not_connected).
-// anyone else, logged in or not, looks among the game's, which anyone can
-// read.
-const findGit = function ({ account, game, headers, since, version }) {
-  const newest = account
-    ? () => api.accountReleases(account, { limit: 20, select: SELECT }, headers)
-    : () =>
-        api.discoverGameReleases(game, { limit: 10, select: SELECT, version });
+// pushed. Null until GitHub Actions has built it. Looked for among the
+// game's releases, which anyone can read, with no token: a git deploy asks
+// what's true for whoever runs it. A release with no game (a repository that
+// isn't connected, which the predeploy refuses first) isn't among them.
+const findGit = function ({ game, since, version }) {
   return () =>
-    newest().then(
-      (rows) =>
-        (rows ?? []).find(
-          (r) =>
-            r.source === "github" &&
-            r.version === version &&
-            (r.game === game || r.game === null) &&
-            Date.parse(r.created_at) >= since - SKEW,
-        ) ?? null,
-    );
+    api
+      .discoverGameReleases(game, { limit: 10, select: SELECT, version })
+      .then(
+        (rows) =>
+          (rows ?? []).find(
+            (r) =>
+              r.source === "github" &&
+              r.version === version &&
+              r.game === game &&
+              Date.parse(r.created_at) >= since - SKEW,
+          ) ?? null,
+      );
 };
 
 // [function]
@@ -123,28 +120,19 @@ const pollRelease = function (find, timeout, onRelease) {
 // [function]
 
 // waits on a deploy's release. `deployed` is what the deploy resolved: a
-// direct deploy's has the release's id, and a git deploy's its game.
-// `owner` is the game's account, when it's known: only they get Studio's
-// link, since only they can open it. A token's account isn't known.
+// direct deploy's has the release's id, and a git deploy's its game. A git
+// deploy has no `current`: it never uses a login. Studio's link is for
+// everyone, since Studio asks whoever opens it to log in.
 const main = function (
   current,
   deployed,
-  { git: isGit, owner, root, since, timeout },
+  { git: isGit, root, since, timeout },
   { onRelease } = {},
 ) {
-  const headers = api.auth(current?.session?.access_token);
   const game = deployed.game;
-  const account = current?.token ? null : (current?.user?.id ?? null);
-  const owns = !isGit || (account !== null && account === owner);
   const find = isGit
-    ? findGit({
-        account: owns ? account : null,
-        game,
-        headers,
-        since,
-        version: deployed.version.to,
-      })
-    : findDirect(deployed.release, headers);
+    ? findGit({ game, since, version: deployed.version.to })
+    : findDirect(deployed.release, api.auth(current?.session?.access_token));
   return Promise.all([
     pollRelease(find, timeout, onRelease),
     isGit ? actionsUrl(root) : null,
@@ -152,7 +140,7 @@ const main = function (
     .then(([{ release, timedOut }, actions]) => ({
       actions,
       release,
-      studio: owns ? studioUrl(game, "builds") : null,
+      studio: studioUrl(game, "builds"),
       timedOut,
     }))
     .catch(ended(current));

package/src/action/predeploy/tool-git.js

@@ -39,11 +39,12 @@ const answerOf = function (request) {
 // [function]
 
 // what Arcadible would refuse in the release, refused before the tag is pushed: a
-// game that was never deployed (a release can't create one), and a version
-// that's already published. The lookups are public, so this needs no login.
+// game that was never deployed (a release can't create one), a version
+// that's already published, and a handle that isn't the game's (only a
+// direct deploy changes one, so a collaborator's push can't). The lookups
+// are public, so this needs no login.
 // when Arcadible can't be reached, it warns and pushes anyway: a release
 // shouldn't depend on the API, and Arcadible still checks.
-// resolves with the game's owner, or null when Arcadible can't be reached.
 const ensurePublishable = function ({ handle, id, version }, handler) {
   return Promise.all([
     answerOf(api.discoverGame(id)),
@@ -64,9 +65,17 @@ const ensurePublishable = function ({ handle, id, version }, handler) {
       }
       return null;
     }
-    return build.status === 200
-      ? published.refuse(id, version)
-      : (game.data?.account ?? null);
+    if (build.status === 200) {
+      return published.refuse(id, version);
+    }
+    const current = game.data?.handle ?? null;
+    if ((handle ?? null) !== current) {
+      throw new ArcError(
+        cfgcode.GAME_HANDLE_CHANGED,
+        phrase.gameHandleChanged(handle, current),
+      );
+    }
+    return null;
   });
 };
 
@@ -116,17 +125,20 @@ const ensureConnected = function (root, { handle, id }) {
 // [function]
 
 // the release's checks: its tag is free, Arcadible would publish it, and
-// origin is its connected repository. resolves with the version, and the
-// game's owner, who waits on the release among their own.
+// origin is its connected repository. resolves with the version.
 const ensureRelease = function (root, game, handler) {
   return ensureTagFree(root, game.version)
     .then(() => ensurePublishable(game, handler))
-    .then((owner) => Promise.all([owner, ensureConnected(root, game)]))
-    .then(([owner]) => ({ owner, to: game.version }));
+    .then(() => ensureConnected(root, game))
+    .then(() => ({ to: game.version }));
 };
 
 // [function]
 
+// a git deploy needs no login, and never uses one: anyone who can push can
+// release, and so can tools other than arc. Every lookup is public, so its
+// answer is the same whoever runs it, and true when it's asked; the release
+// pipeline has the final word.
 const main = function (conf, { onPredeployBegin, ...handler }) {
   const root = conf.root;
   if (onPredeployBegin) {

package/src/action/predeploy/tool.js

@@ -12,6 +12,8 @@ const ensureUnpublished = ac.ensureUnpublished;
 
 // [function]
 
+// a direct deploy needs a login. Each lookup uses its token or not, as it
+// needs, and its answer is true when it's asked.
 const main = function (current, conf, { onPredeployBegin, ...handler }) {
   if (onPredeployBegin) {
     onPredeployBegin({ root: conf.root });

package/src/action/serve/tool.js

@@ -22,6 +22,7 @@ const commands = require("../../util/command");
 const error = require("../../util/error");
 const files = require("../../serve/files");
 const given = require("../../parser/given");
+const media = require("../../parser/media");
 const os = require("../../util/os");
 const phrase = require("../../phrase");
 const reload = require("../../serve/reload");
@@ -36,6 +37,7 @@ const configDir = os.configDir;
 const dirFiles = files.dirFiles;
 const join = path.join;
 const pathExists = fs.pathExists;
+const readFile = fs.promises.readFile;
 const relative = path.relative;
 const remoteFiles = remote.remoteFiles;
 const resolvePath = path.resolve;
@@ -92,6 +94,17 @@ const probe = async function (url) {
 
 // [function]
 
+// the project's store icon, .arcadible/icon.png, or null: found by its exact
+// name, as `arc deploy` finds it, each time it's asked for.
+const storeIcon = function (root) {
+  return async () => {
+    const { game } = await media(root);
+    return game.icon ? readFile(join(root, game.icon)) : null;
+  };
+};
+
+// [function]
+
 // listens, turning a port in use into its code.
 const listen = async function (options) {
   try {
@@ -125,6 +138,7 @@ const main = async function (conf) {
   const project = await given(conf);
   const game = project.game;
   const options = {
+    icon: storeIcon(root),
     info: {
       channel: CHANNEL,
       id: game.id ?? UNNAMED,

package/src/api.js

@@ -136,19 +136,9 @@ const release = function (id, params, headers) {
   return request.get(endpoint(pathOf`/releases/${id}`, params), headers);
 };
 
-// [function]
-
-const accountReleases = function (id, params, headers) {
-  return request.get(
-    endpoint(pathOf`/accounts/${id}/releases`, params),
-    headers,
-  );
-};
-
 // [export]
 
 module.exports = {
-  accountReleases,
   auth,
   discoverGame,
   discoverGameBuild,

package/src/config/code.js

@@ -49,10 +49,11 @@ const CLI = {
 };
 // a release's reasons, from the pipeline (the API's
 // db/type/release_reason.sql). The CLI shares them, so a name means the same
-// thing wherever it appears: GAME_UNAVAILABLE, INTERNAL, REPO_NOT_CONNECTED,
-// and VERSION_EXISTS are the CLI's too.
+// thing wherever it appears: GAME_HANDLE_CHANGED, GAME_UNAVAILABLE, INTERNAL,
+// as well as REPO_NOT_CONNECTED and VERSION_EXISTS, are the CLI's too.
 const RELEASE = {
   BUILD_RATE_LIMITED: "build_rate_limited",
+  GAME_HANDLE_CHANGED: "game_handle_changed",
   GAME_LIMIT_REACHED: "game_limit_reached",
   GAME_MISMATCH: "game_mismatch",
   GAME_UNAVAILABLE: "game_unavailable",

package/src/phrase.js

@@ -225,6 +225,17 @@ const gameHandleTaken = function (handle) {
 
 // [function]
 
+// a git release that would change the game's handle, which only a direct
+// deploy does.
+const gameHandleChanged = function (handle, current) {
+  return blocks(
+    `The handle in arcadible.toml (${handle ?? "none"}) isn't the game's on ${TITLE} (${current ?? "none"}).`,
+    `Only ${cmdDeploy()} changes a handle: deploy with it, or set the handle back.`,
+  );
+};
+
+// [function]
+
 const gameHandleLapsed = function (handle) {
   return `Handle ${handle} lapsed, so deploying without it.\nA production release takes it back.`;
 };
@@ -764,12 +775,12 @@ const packageUncompressedTooLarge = function (size) {
 
 // a failed release's message, a sentence to a line, then its reason code
 // and where to see it.
-// `studio` is the game's builds in Studio, for its owner; anyone else can't
-// open it.
+// `studio` is the game's builds in Studio, which asks whoever opens it to
+// log in.
 const releaseFailed = function ({ message }, studio) {
   return blocks(
     (message ?? "No reason given.").split(/(?<=\.)\s+/u).join("\n"),
-    ...(studio ? [[`${TITLE} Studio:`, studio]] : []),
+    [`${TITLE} Studio:`, studio],
   );
 };
 
@@ -791,18 +802,12 @@ const releaseTimedOut = function (
   { actions, found, git, studio },
 ) {
   const head = `Waited ${waited(seconds)} for v${version}.`;
-  if ((found || !git) && studio) {
+  if (found || !git) {
     return blocks(head, [
       `It may still finish. See it in ${TITLE} Studio:`,
       studio,
     ]);
   }
-  if (found) {
-    return blocks(head, [
-      "It may still finish.",
-      `The ${TITLE} check on the tagged commit says how it went.`,
-    ]);
-  }
   return blocks(
     head,
     [
@@ -1092,6 +1097,7 @@ module.exports = {
   docMediaType,
   docTagUnallowed,
   errorCode,
+  gameHandleChanged,
   gameHandleLapsed,
   gameHandleLimit,
   gameHandleTaken,

package/src/serve/page.js

@@ -3,7 +3,13 @@
 // (site/src/javascripts/arcadible/play/app/page.coffee), with the same
 // sandbox and permissions, and runs the play page's own host for the SDK,
 // so saves are kept by the page, across builds. It reloads the
-// game, and only the game, when told to.
+// game, and only the game, when told to. Its tab shows the game's store
+// icon, as the play page's does, or Arcadible's.
+
+// [import]
+
+const fs = require("node:fs");
+const path = require("node:path");
 
 // [import]
 
@@ -12,6 +18,8 @@ const serveGame = require("./game");
 // [use]
 
 const endWith = serveGame.endWith;
+const join = path.join;
+const readFile = fs.promises.readFile;
 
 // [declare]
 
@@ -23,6 +31,10 @@ const SANDBOX =
 // the page's own paths. Its origin isn't the game's, so they can't collide.
 const HOST = "/_arcadible/host.js";
 const RELOAD = "/_arcadible/reload";
+const ICON = "/_arcadible/icon";
+// the play page's own favicon.ico (app/src/web/arcadible-play/content), for a
+// game without a store icon, and for /favicon.ico, which browsers ask for.
+const FAVICON = join(__dirname, "favicon.ico");
 
 // [declare]
 
@@ -44,6 +56,24 @@ const scriptJson = function (value) {
 
 // [function]
 
+// the play page's favicon.ico, read once.
+let favicon = null;
+const readFavicon = function () {
+  favicon ??= readFile(FAVICON);
+  return favicon;
+};
+
+// [function]
+
+// `png`, the game's store icon, with the corners the play page's icons have
+// (h.border_radius in app/lib/python/offst/util.py: 22% of the size).
+const roundedIcon = function (png) {
+  const href = `data:image/png;base64,${png.toString("base64")}`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><clipPath id="c"><rect width="100" height="100" rx="22"/></clipPath><image href="${href}" width="100" height="100" preserveAspectRatio="xMidYMid slice" clip-path="url(#c)"/></svg>`;
+};
+
+// [function]
+
 const escapeHtml = function (text) {
   return text.replace(
     /[&<>"]/gu,
@@ -70,6 +100,7 @@ const html = function (game) {
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no,viewport-fit=cover">
     <title>${escapeHtml(game.title)}</title>
+    <link href="${ICON}" rel="icon">
     <style>html,body{margin:0;height:100%;overflow:hidden;background:#000}iframe{display:block;width:100%;height:100%;border:0;visibility:hidden}</style>
   </head>
   <body>
@@ -117,9 +148,11 @@ const html = function (game) {
 // [function]
 
 // the request handler for the page's origin. `reloads` keeps the pages
-// listening for a reload; `remote` has the host.
+// listening for a reload; `remote` has the host; `icon()` resolves with the
+// game's store icon, or null.
 const pageHandler = function ({
   game,
+  icon = () => Promise.resolve(null),
   onRemote = () => null,
   reloads,
   remote,
@@ -138,6 +171,26 @@ const pageHandler = function ({
       endWith(req, res, html(game));
       return Promise.resolve();
     }
+    if (pathname === ICON) {
+      // read for each request, so an icon added while serving shows on the
+      // next load.
+      return icon()
+        .catch(() => null)
+        .then(async (png) => {
+          const body = png ? roundedIcon(png) : await readFavicon();
+          res.writeHead(200, {
+            ...HEADERS,
+            "content-type": png ? "image/svg+xml" : "image/x-icon",
+          });
+          endWith(req, res, body);
+        });
+    }
+    if (pathname === "/favicon.ico") {
+      return readFavicon().then((body) => {
+        res.writeHead(200, { ...HEADERS, "content-type": "image/x-icon" });
+        endWith(req, res, body);
+      });
+    }
     if (pathname === RELOAD) {
       reloads.listen(res);
       return Promise.resolve();
@@ -173,4 +226,4 @@ const pageHandler = function ({
 
 // [export]
 
-module.exports = { ALLOW, SANDBOX, html, pageHandler };
+module.exports = { ALLOW, FAVICON, SANDBOX, html, pageHandler };

package/src/serve/server.js

@@ -45,11 +45,20 @@ const listen = function (handler, port, address) {
 // [function]
 
 // starts serving `files` for `info`, `{ id, channel, version, title }`, on
-// `port`, with Arcadible's own files from `remote`. With `src`, another
+// `port`, with Arcadible's own files from `remote`, and the tab's icon from
+// `icon()`, which resolves with a PNG or null. With `src`, another
 // server's page, it frames that instead, and serves no files. Resolves with
 // `{ page, game, reload(), close() }`: the page's origin, the game's URL,
 // and the controls.
-const serve = async function ({ files, info, onRemote, port, remote, src }) {
+const serve = async function ({
+  files,
+  icon,
+  info,
+  onRemote,
+  port,
+  remote,
+  src,
+}) {
   const origins = {
     game: `http://127.0.0.1:${port}`,
     page: `http://localhost:${port}`,
@@ -61,6 +70,7 @@ const serve = async function ({ files, info, onRemote, port, remote, src }) {
     : null;
   const forPage = pageHandler({
     game: { ...info, src: framed },
+    icon,
     onRemote,
     reloads,
     remote,

package/src/util/video.js

@@ -6,8 +6,8 @@ const path = require("node:path");
 
 // [import]
 
-const createFile = require("mp4box").createFile;
 const fs = require("fs-extra");
+const mp4box = require("mp4box");
 
 // [import]
 
@@ -18,6 +18,7 @@ const phrase = require("../phrase");
 
 // [use]
 
+const createFile = mp4box.createFile;
 const checkAspect = media.checkAspect;
 const checkSize = media.checkSize;
 const extname = path.extname;
@@ -30,6 +31,15 @@ const statSync = fs.statSync; // eslint-disable-line no-sync
 
 const NO_TRACK = "no-video-track";
 
+// [configure]
+
+// mp4box prints what it recovers from at its error level, which setLogLevel
+// can't turn down: its colr parser misreads an ICC profile by the box's
+// header, and says so for a video it reads correctly. arc reports a bad video
+// itself, so mp4box only passes on the errors it sends to the file's onError.
+mp4box.Log.error = (mod, msg, isofile) => isofile?.onError?.(mod, msg);
+mp4box.Log.warn = () => {};
+
 // [function]
 
 const readMp4 = function (file) {