arcadible 1.0.10 → 1.0.12

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.10"
+  "version": "1.0.12"
 }

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/pm.js

@@ -9,33 +9,22 @@ const path = require("node:path");
 
 const cfgcode = require("../../config/code");
 const error = require("../../util/error");
+const lockfile = require("../../util/lockfile");
 const phrase = require("../../phrase");
 
 // [use]
 
 const ArcError = error.ArcError;
+const detect = lockfile.detect;
 const existsSync = fs.existsSync; // eslint-disable-line no-sync
 const join = path.join;
 
-// [declare]
-
-const LOCK_FILES = [
-  // npm
-  "package-lock.json",
-  "npm-shrinkwrap.json",
-  // pnpm
-  "pnpm-lock.yaml",
-  // yarn
-  "yarn.lock",
-];
-
 // [function]
 
 // fails when there's a package.json without a lockfile: the release workflow
 // installs exactly what the lockfile pins.
 const ensureLockFile = function (root) {
-  const has = (file) => existsSync(join(root, file));
-  if (has("package.json") && !LOCK_FILES.some(has)) {
+  if (existsSync(join(root, "package.json")) && !detect(root)) {
     return Promise.reject(
       new ArcError(cfgcode.LOCKFILE_MISSING, phrase.lockfileMissing()),
     );

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/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/parser/env.js

@@ -12,6 +12,7 @@ const fs = require("fs-extra");
 
 const cfgcode = require("../config/code");
 const error = require("../util/error");
+const lockfile = require("../util/lockfile");
 const objs = require("../util/objs");
 const phrase = require("../phrase");
 
@@ -19,14 +20,13 @@ const phrase = require("../phrase");
 
 const ArcError = error.ArcError;
 const deepCompact = objs.deepCompact;
+const detect = lockfile.detect;
 const join = path.join;
 const pathExists = fs.pathExists;
 const readFile = fs.readFile;
 
 // [declare]
 
-// the build a package.json build script stands for.
-const NPM_RUN_BUILD = "npm run build";
 const PACKAGE = "package.json";
 
 // [function]
@@ -53,13 +53,19 @@ const parseJson = function (buf) {
 
 // [function]
 
-// package.json's version, and its build script as `npm run build`: run
-// through npm, the script finds the project's own tools on the PATH
-// (node_modules/.bin), and its prebuild and postbuild run, as they do
-// locally. npm runs the scripts of a pnpm or Yarn project too.
-const extract = function (conf) {
+// package.json's version, and its build script as `<manager> run build`, run
+// with the package manager its lockfile names (npm without one): the script
+// finds the project's own tools, and its prebuild and postbuild run, as they do
+// locally. A Yarn project on Plug'n'Play has no node_modules, so only Yarn
+// finds its tools.
+const extract = function (conf, manager) {
+  if (!Object.keys(conf).length) {
+    return {};
+  }
   const game = { version: conf.version };
-  const workflow = conf.scripts?.build ? { build: NPM_RUN_BUILD } : {};
+  const workflow = conf.scripts?.build
+    ? { build: `${manager || "npm"} run build` }
+    : {};
   return deepCompact({ game, workflow }) ?? {};
 };
 
@@ -70,7 +76,7 @@ const main = function (root) {
   return pathExists(file)
     .then((exists) => (exists ? readFile(file, "utf8") : null))
     .then((buf) => (buf === null ? {} : parseJson(buf)))
-    .then((conf) => (Object.keys(conf).length ? extract(conf) : {}));
+    .then((conf) => extract(conf, detect(root)));
 };
 
 // [export]

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/util/lockfile.js

@@ -0,0 +1,35 @@
+"use strict";
+
+// [import]
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+// [use]
+
+const existsSync = fs.existsSync; // eslint-disable-line no-sync
+const join = path.join;
+
+// [declare]
+
+// each package manager, and the lockfiles that mean a project uses it, in the
+// order they're checked, as the release tools' install checks them.
+const LOCKFILES = [
+  ["npm", ["package-lock.json", "npm-shrinkwrap.json"]],
+  ["pnpm", ["pnpm-lock.yaml"]],
+  ["yarn", ["yarn.lock"]],
+];
+
+// [function]
+
+// the package manager a project's lockfile names, or "" when it has none.
+const detect = function (root) {
+  const found = LOCKFILES.find(([, names]) =>
+    names.some((name) => existsSync(join(root, name))),
+  );
+  return found ? found[0] : "";
+};
+
+// [export]
+
+module.exports = { detect };

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) {