arcadible 0.1.38 → 0.1.40

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.38"
+  "version": "0.1.40"
 }

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/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

@@ -95,6 +95,23 @@ const ensureRepo = function (root) {
 
 // [function]
 
+// fails when the project isn't the repository's top level: the release
+// workflow builds from the root, so a project in a directory below it would
+// fail on GitHub, or release the root's game.
+const ensureRoot = function (root) {
+  return git(root, ["rev-parse", "--show-prefix"]).then((stdout) => {
+    const prefix = stdout.trim();
+    if (prefix) {
+      throw new ArcError(
+        cfgcode.PROJECT_NOT_REPO_ROOT,
+        phrase.projectNotRepoRoot(prefix),
+      );
+    }
+  });
+};
+
+// [function]
+
 // fails when HEAD has no release workflow, which Arcadible checks for when the
 // tag arrives (workflow_missing).
 const ensureWorkflow = function (root) {
@@ -178,6 +195,7 @@ module.exports = {
   ensureClean,
   ensureRemote,
   ensureRepo,
+  ensureRoot,
   ensureTagFree,
   ensureWorkflow,
   failWith,

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

@@ -19,6 +19,7 @@ const ensureClean = git.ensureClean;
 const ensureLockFile = pm.ensureLockFile;
 const ensureRemote = git.ensureRemote;
 const ensureRepo = git.ensureRepo;
+const ensureRoot = git.ensureRoot;
 const ensureTagFree = git.ensureTagFree;
 const ensureWorkflow = git.ensureWorkflow;
 const originRepo = git.originRepo;
@@ -71,10 +72,12 @@ const ensurePublishable = function ({ handle, id, version }, handler) {
 // [function]
 
 // the project's checks: a lockfile when there's a package.json, and a clean
-// repository with the release workflow and a reachable origin.
+// repository, whose root is the project, with the release workflow and a
+// reachable origin.
 const ensureProject = function (root) {
   return ensureLockFile(root)
     .then(() => ensureRepo(root))
+    .then(() => ensureRoot(root))
     .then(() => ensureClean(root))
     .then(() => ensureWorkflow(root))
     .then(() => ensureRemote(root));

package/src/config/code.js

@@ -24,6 +24,7 @@ const CLI = {
   LOCKFILE_MISSING: "lockfile_missing",
   LOGIN_EXPIRED: "login_expired",
   LOGIN_FAILED: "login_failed",
+  MANIFEST_MISSING: "manifest_missing",
   NETWORK_ERROR: "network_error",
   NOT_LOGGED_IN: "not_logged_in",
   PACKAGE_FILE_TOO_LARGE: "package_file_too_large",
@@ -33,6 +34,7 @@ const CLI = {
   PACKAGE_UNCOMPRESSED_TOO_LARGE: "package_uncompressed_too_large",
   PARSE_FAILED: "parse_failed",
   PATH_NOT_FOUND: "path_not_found",
+  PROJECT_NOT_REPO_ROOT: "project_not_repo_root",
   SESSION_EXPIRED: "session_expired",
   TEMPLATE_MISSING: "template_missing",
   TEMPLATE_UNAVAILABLE: "template_unavailable",
@@ -43,8 +45,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/parser/project.js

@@ -2,11 +2,16 @@
 
 // [import]
 
+const path = require("node:path");
+
+// [import]
+
 const fs = require("fs-extra");
 
 // [import]
 
 const cfgcode = require("../config/code");
+const cfgproduct = require("../config/product");
 const cfgworkflow = require("../config/workflow");
 const env = require("./env");
 const error = require("../util/error");
@@ -19,7 +24,16 @@ const readme = require("./readme");
 // [use]
 
 const ArcError = error.ArcError;
+const dirname = path.dirname;
+const isAbsolute = path.isAbsolute;
+const join = path.join;
 const pathExists = fs.pathExists;
+const relative = path.relative;
+const sep = path.sep;
+
+// [declare]
+
+const MANIFEST = `${cfgproduct.handle}.toml`;
 
 // [function]
 
@@ -44,6 +58,51 @@ const configWorkflow = function (envWorkflow, manifestWorkflow) {
 
 // [function]
 
+// a directory as the developer would type it: relative to where arc runs
+// when it's there, below it, or above it (`..`), or else its full path.
+const shown = function (dir) {
+  const rel = relative(process.cwd(), dir);
+  const above = rel.split(sep).every((part) => part === "..");
+  return isAbsolute(rel) || (rel.startsWith("..") && !above) ? dir : rel || ".";
+};
+
+// [function]
+
+// the nearest directory above `dir` with a manifest, or null. It's only
+// named in the error's hint: arc never reads a project it wasn't given.
+const nearestAbove = function (dir) {
+  const parent = dirname(dir);
+  if (parent === dir) {
+    return Promise.resolve(null);
+  }
+  return pathExists(join(parent, MANIFEST)).then((exists) => {
+    if (exists) {
+      return parent;
+    }
+    return nearestAbove(parent);
+  });
+};
+
+// [function]
+
+// fails when `root` has no manifest. A game's id is only ever in it, so a
+// project without one can't be deployed, and the likeliest cause is running
+// arc from inside a project: the hint names the project above, if any.
+const ensureManifest = function (root) {
+  return pathExists(join(root, MANIFEST))
+    .then((exists) => (exists ? false : nearestAbove(root)))
+    .then((found) => {
+      if (found !== false) {
+        throw new ArcError(
+          cfgcode.MANIFEST_MISSING,
+          phrase.noManifest(MANIFEST, shown(root), found && shown(found)),
+        );
+      }
+    });
+};
+
+// [function]
+
 // the other sources, once arcadible.toml is read: the README's title is read
 // word for word when arcadible.toml sets the short title.
 const parseSources = function (root, manifestData) {
@@ -66,16 +125,17 @@ const parseSources = function (root, manifestData) {
 
 // [function]
 
-// the project at `root`, which must exist: a mistyped -C would otherwise
-// read as an empty project.
+// the project at `root`, which must exist, with its manifest: a mistyped
+// -C would otherwise read as an empty project.
 const main = function (root) {
   return pathExists(root)
     .then((exists) => {
       if (!exists) {
         throw new ArcError(cfgcode.PATH_NOT_FOUND, phrase.unableToFind(root));
       }
-      return manifest(root);
+      return ensureManifest(root);
     })
+    .then(() => manifest(root))
     .then((manifestData) => parseSources(root, manifestData));
 };
 

package/src/phrase.js

@@ -214,6 +214,26 @@ const gitRemoteMissing = function () {
 
 // [function]
 
+const noManifest = function (file, dir, found) {
+  return blocks(
+    dir === "." ? `No ${file} in this directory.` : `No ${file} in ${dir}`,
+    found
+      ? `The project is in \`${found}\`: run arc there, or pass \`-C ${found}\`.`
+      : "Run arc in the project's directory, or pass -C, or start a project with `arc init`.",
+  );
+};
+
+// [function]
+
+const projectNotRepoRoot = function (prefix) {
+  return blocks(
+    `arc deploy git releases the project at the repository's root, and this one is in ${prefix}`,
+    "Deploy it with `arc deploy`, or give it a repository of its own.",
+  );
+};
+
+// [function]
+
 const gitRepoMissing = function () {
   return blocks(
     "No Git repository found.",
@@ -771,6 +791,7 @@ module.exports = {
   loginFailed,
   noGameId,
   noLockFile,
+  noManifest,
   noProductionRelease,
   noTemplate,
   noVideoMetadata,
@@ -783,6 +804,7 @@ module.exports = {
   packageTooLarge,
   packageTooManyFiles,
   packageUncompressedTooLarge,
+  projectNotRepoRoot,
   releaseFailed,
   releasePublished,
   releaseTimedOut,