arcadible 0.1.37 → 0.1.39

package/bin/arc-deploy.js

@@ -109,10 +109,10 @@ const handler = function ({ json, pb, quiet, sw }) {
 
 // what was deployed, whether workflow.build ran, where it will be once it's
 // published (the store only shows production), and what happens next. Once
-// waited on, it's published, so it says so. `note` is a last block.
+// waited on, it's published, so it says so.
 const report = function (
   { built, channel, store, tag, url, version },
-  { git, note, published },
+  { git, published },
 ) {
   let heading = git
     ? phrase.tagPushed(tag)
@@ -124,36 +124,19 @@ const report = function (
     heading = phrase.releasePublished(version.to, channel, built);
     next = null;
   }
-  log.result(heading, [
-    store ? ["Store:", store] : null,
-    ["Play:", url],
-    next,
-    note ?? null,
-  ]);
+  log.result(heading, [store ? ["Store:", store] : null, ["Play:", url], next]);
 };
 
 // [function]
 
 // the account, or null when there's none or it can't be refreshed: for a git
-// deploy, which only needs one to wait.
+// deploy, which needs none.
 const whoamiIfAny = function (opts) {
   return whoami(opts).catch(() => null);
 };
 
 // [function]
 
-// whether `current` can wait for a git release: only the game's owner can see
-// its releases. A token's account isn't known, so it waits, and so does any
-// account when the owner couldn't be looked up.
-const canWait = function (current, owner) {
-  if (!current) {
-    return false;
-  }
-  return Boolean(current.token) || owner === null || owner === current.user?.id;
-};
-
-// [function]
-
 // the release, as `--json` prints it.
 const releaseJson = function (row) {
   if (!row) {
@@ -178,7 +161,7 @@ const waitAndReport = async function (
   current,
   deployed,
   result,
-  { git, json, quiet, root, since, timeout },
+  { git, json, owner, quiet, root, since, timeout },
 ) {
   let sw = new SpinnerWheel(phrase.releaseWaiting(git));
   sw.start(json || quiet);
@@ -188,7 +171,7 @@ const waitAndReport = async function (
     waited = await wait(
       current,
       deployed,
-      { git, root, since, timeout },
+      { git, owner, root, since, timeout },
       {
         onRelease() {
           // found: GitHub Actions is done, and Arcadible publishes it now.
@@ -263,8 +246,9 @@ const start = function (argv) {
   const timeout = Number(argv.timeout ?? TIMEOUT[git ? "git" : "direct"]);
   const root = resolve(process.cwd(), argv.cwd);
   let pb = null;
-  // the note when a git deploy doesn't wait: who can wait for it.
-  let notWaited = phrase.releaseNotWaited();
+  // the game's account, when Arcadible could say: a git deploy's owner waits
+  // among their own releases.
+  let owner = null;
   // the project, parsed once and given to each step. A build can write files
   // the manifest reads, such as art, so it's parsed again after one runs.
   let parsed = null;
@@ -288,10 +272,9 @@ const start = function (argv) {
       sw.stop(true);
       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. The
-      // account, when there is one, checks the owner's repository is
-      // connected, and waits for the release, which needs the game's owner,
-      // so a git deploy that isn't logged in neither checks nor waits.
+      // 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.
       if (git) {
         return whoamiIfAny({ handler: handler({ json, pb, quiet, sw }) });
       }
@@ -318,15 +301,12 @@ const start = function (argv) {
     })
     .then(([current, predeployed]) => {
       sw.stop(true);
-      const waits = !git || canWait(current, predeployed.owner ?? null);
-      if (current && !waits) {
-        notWaited = phrase.releaseNotWaitedOwner();
-      }
+      owner = predeployed.owner ?? null;
       sw = new SpinnerWheel("Building... %s");
       sw.start(git || json || quiet);
       return Promise.all([
-        // whoami, kept only to wait with
-        waits ? current : null,
+        // whoami
+        current,
         // build
         git ? null : build({ project: parsed, root }),
       ]);
@@ -380,10 +360,11 @@ const start = function (argv) {
       delete shown.release;
       const result = git ? shown : { built, ...shown };
       sw.stop(true);
-      if (argv.wait && current) {
+      if (argv.wait) {
         return waitAndReport(current, deployed, result, {
           git,
           json,
+          owner,
           quiet,
           root,
           since,
@@ -393,10 +374,7 @@ const start = function (argv) {
       if (json) {
         print(result);
       } else if (!quiet) {
-        report(result, {
-          git,
-          note: argv.wait ? notWaited : null,
-        });
+        report(result, { git });
       }
       return null;
     })

package/bin/arc-init.js

@@ -32,7 +32,6 @@ const spinner = require("../src/util/spinner");
 const abort = output.abort;
 const ArcError = error.ArcError;
 const findRc = rc.findRc;
-const join = path.join;
 const pathExists = fs.pathExists;
 const print = output.print;
 const resolve = path.resolve;
@@ -95,7 +94,8 @@ const start = function (argv) {
 // [function]
 
 const patch = function (cwd, project) {
-  return pathExists(join(resolve(process.cwd(), cwd), project));
+  // project may be absolute, as action/init/tool.js resolves it.
+  return pathExists(resolve(process.cwd(), cwd, project));
 };
 
 // [function]

package/package.json

@@ -75,5 +75,5 @@
   "scripts": {
     "test": "node --test \"test/**/*.test.js\""
   },
-  "version": "0.1.37"
+  "version": "0.1.39"
 }

package/src/action/build/tool.js

@@ -25,9 +25,11 @@ const resolvePath = path.resolve;
 
 // [function]
 
+// a build's output has no limit: exec's default maxBuffer, 1 MB, would kill a
+// verbose build that otherwise succeeds.
 const execBuild = function (command, { cwdPath }) {
   return new Promise((resolve, reject) => {
-    exec(command, { cwd: cwdPath }, (err, stdout, stderr) => {
+    exec(command, { cwd: cwdPath, maxBuffer: Infinity }, (err, stdout, stderr) => {
       if (err) {
         const { code, signal } = err;
         reject(

package/src/action/deploy/wait.js

@@ -67,15 +67,16 @@ 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. It's looked for among the
-// account's releases, which include one with no game: a repository that
-// isn't connected fails that way (repo_not_connected). A token's account
-// isn't known, so it looks among the game's.
+// 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.gameReleases(game, { limit: 10, select: SELECT, version }, headers);
+        api.discoverGameReleases(game, { limit: 10, select: SELECT, version });
   return () =>
     newest().then(
       (rows) =>
@@ -127,17 +128,21 @@ const poll = function (find, timeout, onRelease) {
 
 // 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.
 const main = function (
   current,
   deployed,
-  { git: isGit, root, since, timeout },
+  { git: isGit, owner, 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: current?.user?.id ?? null,
+        account: owns ? account : null,
         game,
         headers,
         since,
@@ -150,7 +155,7 @@ const main = function (
   ]).then(([{ release, timedOut }, actions]) => ({
     actions,
     release,
-    studio: studioUrl(game),
+    studio: owns ? studioUrl(game) : null,
     timedOut,
   }));
 };

package/src/action/open/tool.js

@@ -2,12 +2,13 @@
 
 // [import]
 
+const links = require("../../util/links");
 const project = require("../../parser/project");
 
 // [function]
 
 const openUrl = function (id) {
-  return id ? { page: `/play/${id}` } : null;
+  return id ? { page: links.storePage(id) } : null;
 };
 
 // [function]

package/src/action/predeploy/git.js

@@ -22,6 +22,13 @@ const HANDLE = cfgproduct.handle;
 const PREFIX = `${HANDLE}/release/v`;
 // the release workflow, which builds the release on GitHub Actions.
 const WORKFLOW = ".github/workflows/arcadible-release.yml";
+// a remote's URL: `scheme://[user@]host/path`, or scp-like
+// `[user@]host:path`. A path on this machine is neither.
+const URL_REMOTE = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/\s]+@)?[^/\s]+\/(\S+)$/iu;
+const URL_SCP = /^(?:[^@/\s]+@)?[^:/\s]{2,}:(?!\/)(\S+)$/u;
+// the names GitHub allows: an account's, and a repository's.
+const NAME_OWNER = /^[A-Za-z0-9-]{1,39}$/u;
+const NAME_REPO = /^[A-Za-z0-9._-]{1,100}$/u;
 
 // [function]
 
@@ -99,6 +106,40 @@ const ensureWorkflow = function (root) {
 
 // [function]
 
+// a remote URL's repository, as { owner, name }: the last two parts of its
+// path. The host isn't checked, so an SSH alias for GitHub works too. Null
+// for a path on this machine, or one that isn't owner/name.
+const repoOf = function (url) {
+  const path = URL_REMOTE.exec(url)?.[1] ?? URL_SCP.exec(url)?.[1] ?? null;
+  if (!path) {
+    return null;
+  }
+  const parts = path
+    .replace(/\/+$/u, "")
+    .replace(/\.git$/u, "")
+    .split("/");
+  if (parts.length < 2) {
+    return null;
+  }
+  const [owner, name] = parts.slice(-2);
+  return NAME_OWNER.test(owner) && NAME_REPO.test(name)
+    ? { name, owner }
+    : null;
+};
+
+// [function]
+
+// origin's repository, from its URL as configured (before any `insteadOf`),
+// or null when it has none, or it isn't a repository on a host.
+const originRepo = function (root) {
+  return git(root, ["config", "--get", "remote.origin.url"]).then(
+    (stdout) => repoOf(stdout.trim()),
+    () => null,
+  );
+};
+
+// [function]
+
 const hasTagLocal = function (root, tag) {
   return git(root, ["tag", "--list", tag]).then((stdout) =>
     Boolean(stdout.trim()),
@@ -141,5 +182,7 @@ module.exports = {
   ensureWorkflow,
   failWith,
   git,
+  originRepo,
+  repoOf,
   tagOf,
 };

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

@@ -21,6 +21,7 @@ const ensureRemote = git.ensureRemote;
 const ensureRepo = git.ensureRepo;
 const ensureTagFree = git.ensureTagFree;
 const ensureWorkflow = git.ensureWorkflow;
+const originRepo = git.originRepo;
 
 // [function]
 
@@ -81,55 +82,55 @@ const ensureProject = function (root) {
 
 // [function]
 
-// fails when the game has no repository connected, which Arcadible would
-// refuse (repo_not_connected) after GitHub Actions had built it. Only the
-// game's owner can see its repository, so it's checked only when they're
-// logged in, and skipped when Arcadible can't be reached.
-const ensureConnected = function (current, { handle, id }, owner) {
-  if (!owner || current?.token || current?.user?.id !== owner) {
-    return Promise.resolve();
-  }
-  const headers = api.auth(current.session?.access_token);
-  return api.gameRepos(id, { select: "id" }, headers).then(
-    (repos) => {
-      if (!repos?.length) {
+// fails when origin isn't the game's connected repository, which Arcadible
+// would refuse (repo_not_connected) once GitHub Actions had built it. It's
+// asked by name, which needs no login, so it checks whoever pushes. Skipped
+// when origin is a path on this machine, or Arcadible can't be reached.
+const ensureConnected = function (root, { handle, id }) {
+  let repo = null;
+  return originRepo(root)
+    .then((found) => {
+      repo = found;
+      return repo
+        ? lookup(api.discoverGameRepo(id, repo.owner, repo.name))
+        : null;
+    })
+    .then((connected) => {
+      if (connected?.status === 404) {
         throw new ArcError(
           cfgcode.REPO_NOT_CONNECTED,
           phrase.gameRepoMissing(
             handle ?? id,
+            `${repo.owner}/${repo.name}`,
             `${cfguri.HOST_HTTP_STUDIO}/games/${id}/repository`,
           ),
         );
       }
-    },
-    () => null,
-  );
+    });
 };
 
 // [function]
 
-// the release's checks: its tag is free, Arcadible would publish it, and its
-// repository is connected. resolves with the version, and the game's owner,
-// who alone can wait for the release.
-const ensureRelease = function (root, current, game, handler) {
+// 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.
+const ensureRelease = function (root, game, handler) {
   return ensureTagFree(root, game.version)
     .then(() => ensurePublishable(game, handler))
-    .then((owner) =>
-      Promise.all([owner, ensureConnected(current, game, owner)]),
-    )
+    .then((owner) => Promise.all([owner, ensureConnected(root, game)]))
     .then(([owner]) => ({ owner, to: game.version }));
 };
 
 // [function]
 
-const main = function (current, conf, { onPredeployBegin, ...handler }) {
+const main = function (conf, { onPredeployBegin, ...handler }) {
   const root = conf.root;
   if (onPredeployBegin) {
     onPredeployBegin();
   }
   return given(conf)
     .then(({ game }) => Promise.all([game, ensureProject(root)]))
-    .then(([game]) => ensureRelease(root, current, game, handler));
+    .then(([game]) => ensureRelease(root, game, handler));
 };
 
 // [export]

package/src/api.js

@@ -77,35 +77,46 @@ const discoverGameBuild = function (id, version, params, headers) {
 
 // [function]
 
-const gameBuild = function (id, version, params, headers) {
+// a game's releases, which anyone can read: what each says about itself.
+const discoverGameReleases = function (id, params, headers) {
   return request.get(
-    endpoint(`/games/${id}/builds/${version}`, params),
+    endpoint(`/discover/games/${id}/releases`, params),
     headers,
   );
 };
 
 // [function]
 
-const release = function (id, params, headers) {
-  return request.get(endpoint(`/releases/${id}`, params), headers);
+// the game's connected repository, if it's `owner/name`; otherwise 404.
+const discoverGameRepo = function (id, owner, name, params, headers) {
+  return request.get(
+    endpoint(
+      `/discover/games/${id}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`,
+      params,
+    ),
+    headers,
+  );
 };
 
 // [function]
 
-const accountReleases = function (id, params, headers) {
-  return request.get(endpoint(`/accounts/${id}/releases`, params), headers);
+const gameBuild = function (id, version, params, headers) {
+  return request.get(
+    endpoint(`/games/${id}/builds/${version}`, params),
+    headers,
+  );
 };
 
 // [function]
 
-const gameRepos = function (id, params, headers) {
-  return request.get(endpoint(`/games/${id}/repos`, params), headers);
+const release = function (id, params, headers) {
+  return request.get(endpoint(`/releases/${id}`, params), headers);
 };
 
 // [function]
 
-const gameReleases = function (id, params, headers) {
-  return request.get(endpoint(`/games/${id}/releases`, params), headers);
+const accountReleases = function (id, params, headers) {
+  return request.get(endpoint(`/accounts/${id}/releases`, params), headers);
 };
 
 // [export]
@@ -116,10 +127,10 @@ module.exports = {
   discoverGame,
   discoverGameBuild,
   discoverGameBuilds,
+  discoverGameReleases,
+  discoverGameRepo,
   flow,
   gameBuild,
-  gameReleases,
-  gameRepos,
   postAuthRefresh,
   postFlow,
   postUpload,

package/src/cli/predeploy.js

@@ -9,7 +9,7 @@ const predeployToolGit = require("../action/predeploy/tool-git");
 
 const main = function ({ current, git, handler, ...conf }) {
   return git
-    ? predeployToolGit(current, conf, handler)
+    ? predeployToolGit(conf, handler)
     : predeployTool(current, conf, handler);
 };
 

package/src/config/code.js

@@ -43,8 +43,8 @@ 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, and VERSION_EXISTS
-// are the CLI's too.
+// thing wherever it appears: GAME_UNAVAILABLE, INTERNAL, REPO_NOT_CONNECTED,
+// and VERSION_EXISTS are the CLI's too.
 const RELEASE = {
   APP_NOT_INSTALLED: "app_not_installed",
   EXPIRED: "expired",

package/src/config/url.js

@@ -13,7 +13,6 @@ const HANDLE = cfgproduct.handle;
 
 module.exports = {
   ERRORS: `${cfguri.HOST_HTTP_DEVELOPER}/references/errors`,
-  GETTING_STARTED: `${cfguri.HOST_HTTP_DEVELOPER}/getting-started`,
   LINK: `${cfguri.HOST_HTTP_ACCOUNT}/link`,
   MANIFEST: `${cfguri.HOST_HTTP_DEVELOPER}/references/${HANDLE}-manifest`,
 };

package/src/phrase.js

@@ -171,9 +171,10 @@ const gameNotDeployed = function (game) {
 
 // [function]
 
-const gameRepoMissing = function (game, url) {
-  return blocks(`${game} isn't connected to a GitHub repository.`, [
-    `Connect this repository in ${TITLE} Studio, on the game's Repository tab:`,
+// origin isn't the game's connected repository: none is, or another is.
+const gameRepoMissing = function (game, repo, url) {
+  return blocks(`${repo} isn't ${game}'s repository on ${TITLE}.`, [
+    `The game's owner connects it in ${TITLE} Studio, on the game's Repository tab, and connects it again if it was renamed on GitHub:`,
     url,
   ]);
 };
@@ -435,30 +436,18 @@ 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.
 const releaseFailed = function ({ message, reason }, studio) {
   return blocks(
     (message ?? "").split(/(?<=\.)\s+/u).join("\n"),
     `Reason: ${reason}.`,
-    [`${TITLE} Studio:`, studio],
+    ...(studio ? [[`${TITLE} Studio:`, studio]] : []),
   );
 };
 
 // [function]
 
-// a git deploy that isn't logged in can't read its release, so it doesn't
-// wait for it.
-const releaseNotWaited = function () {
-  return `Log in to wait for it: ${cmdLogin()}.`;
-};
-
-// [function]
-
-const releaseNotWaitedOwner = function () {
-  return "Only the game's owner can wait for its release.";
-};
-
-// [function]
-
 // `built` when workflow.build ran first.
 const releasePublished = function (version, channel, built) {
   return `${built ? "Built and published" : "Published"} v${version} to ${channel}.`;
@@ -475,12 +464,18 @@ const releaseTimedOut = function (
   { actions, found, git, studio },
 ) {
   const head = `Waited ${waited(seconds)} for v${version}.`;
-  if (found || !git) {
+  if ((found || !git) && studio) {
     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,
     [
@@ -789,8 +784,6 @@ module.exports = {
   packageTooManyFiles,
   packageUncompressedTooLarge,
   releaseFailed,
-  releaseNotWaited,
-  releaseNotWaitedOwner,
   releasePublished,
   releaseTimedOut,
   releaseWaiting,