arcadible 1.0.4 → 1.0.6

package/README.md

@@ -7,7 +7,7 @@
 <h1 align="center">Arcadible CLI</h1>
 
 <p align="center">
-  Create, play, and share games made with AI.
+  Ship your game to players in one command.
 </p>
 
 <p align="center">

package/package.json

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

package/src/action/build/tool.js

@@ -35,9 +35,13 @@ const execBuild = function (command, { cwdPath }) {
       if (err) {
         const { code, signal } = err;
         reject(
-          new ArcError(cfgcode.BUILD_FAILED, phrase.buildFailed({ code, signal, stderr }), {
-            cause: err,
-          }),
+          new ArcError(
+            cfgcode.BUILD_FAILED,
+            phrase.buildFailed({ code, signal, stderr, stdout }),
+            {
+              cause: err,
+            },
+          ),
         );
         return;
       }

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

@@ -12,7 +12,6 @@ const repo = require("../predeploy/git");
 // [use]
 
 const ArcError = error.ArcError;
-const failWith = repo.failWith;
 const git = repo.git;
 const tagOf = repo.tagOf;
 
@@ -25,7 +24,13 @@ const createTag = function (root, version) {
       : phrase.versionPrerelease(version);
   return git(root, ["tag", "-a", tagOf(version), "-m", message]).then(
     () => null,
-    failWith(cfgcode.GIT_TAG_CREATE_FAILED, phrase.gitTagCreateFailed(version)),
+    (err) => {
+      throw new ArcError(
+        cfgcode.GIT_TAG_CREATE_FAILED,
+        phrase.gitTagCreateFailed(version, err.stderr),
+        { cause: err },
+      );
+    },
   );
 };
 
@@ -52,7 +57,7 @@ const pushTag = function (root, version) {
         version,
         new ArcError(
           cfgcode.GIT_TAG_PUSH_FAILED,
-          phrase.gitTagPushFailed(version),
+          phrase.gitTagPushFailed(version, err.stderr),
           {
             cause: err,
           },

package/src/action/init/tool.js

@@ -15,6 +15,7 @@ const cfgcode = require("../../config/code");
 const error = require("../../util/error");
 const manifest = require("./manifest");
 const phrase = require("../../phrase");
+const templates = require("../../config/template");
 
 // [use]
 
@@ -38,10 +39,14 @@ const removeLicense = function (dest) {
 
 // [function]
 
+// a starter's name on its own, such as `blank`, suggests the starter.
 const unavailable = function (src, cause) {
+  const starter = templates.choices.find(
+    ({ value }) => value.split("/").pop() === src,
+  );
   return new ArcError(
     cfgcode.TEMPLATE_UNAVAILABLE,
-    phrase.templateUnavailable(src),
+    phrase.templateUnavailable(src, starter?.value),
     { cause },
   );
 };
@@ -64,8 +69,11 @@ const scaffold = function (src, dest, { onInitBegin }) {
   if (onInitBegin) {
     onInitBegin({ dest, src });
   }
-  return degit(src, { cache: false, force: true, verbose: false })
-    .clone(dest)
+  // degit throws as it's made when it can't parse `src`.
+  return Promise.resolve()
+    .then(() =>
+      degit(src, { cache: false, force: true, verbose: false }).clone(dest),
+    )
     .catch((ex) => {
       throw unavailable(src, ex);
     })

package/src/action/pack/tool.js

@@ -48,13 +48,20 @@ const SIZE_PARTIAL = cfglimit.ZIP_SIZE;
 
 // [function]
 
-// the build's folder named like the reserved one, if it has one.
+// the first path at the build's root that's Arcadible's, if it has one: a
+// folder named like the reserved one, or the manifest or media that packing
+// adds, as `arc validate` checks deploy_dir. A folder ends with "/".
 const findReserved = function (zip) {
-  const folder = zip
+  return zip
     .entries()
     .map((entry) => entry.name.split("/"))
-    .find((parts) => parts.length > 1 && parts[0].toLowerCase() === RESERVED);
-  return folder?.[0];
+    .map((parts) => (parts.length > 1 ? `${parts[0]}/` : parts[0]))
+    .find(
+      (name) =>
+        name.toLowerCase() === `${RESERVED}/` ||
+        name === MANIFEST ||
+        name === `${MEDIA}/`,
+    );
 };
 
 // [function]

package/src/action/predeploy/git.js

@@ -35,9 +35,9 @@ const NAME_REPO = /^[A-Za-z0-9._-]{1,100}$/u;
 // runs git in `root`, and resolves with its stdout.
 const git = function (root, args) {
   return new Promise((resolve, reject) => {
-    execFile("git", ["-C", root, ...args], (err, stdout) => {
+    execFile("git", ["-C", root, ...args], (err, stdout, stderr) => {
       if (err) {
-        reject(err);
+        reject(Object.assign(err, { stderr }));
         return;
       }
       resolve(stdout);

package/src/phrase.js

@@ -6,8 +6,10 @@ const cfgproduct = require("./config/product");
 
 // [declare]
 
+const HANDLE = cfgproduct.handle;
 const TITLE = cfgproduct.title;
 const TOOL = cfgproduct.tool;
+const TAIL_LINES = 20;
 
 // [function]
 
@@ -21,6 +23,22 @@ const blocks = function (reason, ...details) {
 
 // [function]
 
+// the last lines a tool printed, stdout's then stderr's, since some, such as
+// tsc, print their errors on stdout, or "" when it printed nothing. Lines
+// left out are marked with "…".
+const tail = function (...outputs) {
+  const lines = outputs
+    .map((output) => output?.trim())
+    .filter(Boolean)
+    .join("\n")
+    .split("\n");
+  return lines.length > TAIL_LINES
+    ? ["…", ...lines.slice(-TAIL_LINES)].join("\n")
+    : lines.join("\n");
+};
+
+// [function]
+
 // a wait, in words: "5 minutes", "90 seconds".
 const waited = function (seconds) {
   if (seconds % 60 === 0) {
@@ -39,10 +57,10 @@ const aborted = function (command) {
 
 // [function]
 
-// a build that exited with `code`, or was stopped by `signal`, with what it
-// wrote to stderr.
-const buildFailed = function ({ code, signal, stderr }) {
-  const output = stderr?.trim();
+// a build that exited with `code`, or was stopped by `signal`, with the end
+// of what it printed.
+const buildFailed = function ({ code, signal, stderr, stdout }) {
+  const output = tail(stdout, stderr);
   return blocks(
     signal
       ? `Build stopped by ${signal}.`
@@ -500,18 +518,27 @@ const gitRepoMissing = function () {
 
 // [function]
 
-const gitTagCreateFailed = function (version) {
-  return blocks(`Unable to create Git tag for v${version}.`, [
-    "Check that the repository has a commit.",
-    "Check that your Git name and email are set.",
-  ]);
+// with the end of what git printed, such as a lock file it found.
+const gitTagCreateFailed = function (version, stderr) {
+  const output = tail(stderr);
+  return blocks(
+    `Unable to create Git tag for v${version}.`,
+    ...(output ? [output] : []),
+    [
+      "Check that the repository has a commit.",
+      "Check that your Git name and email are set.",
+    ],
+  );
 };
 
 // [function]
 
-const gitTagPushFailed = function (version) {
+// with the end of what git printed, such as a hook's refusal.
+const gitTagPushFailed = function (version, stderr) {
+  const output = tail(stderr);
   return blocks(
     `Unable to push Git tag for v${version}.`,
+    ...(output ? [output] : []),
     "Check that you can push to origin.",
   );
 };
@@ -701,10 +728,14 @@ const packageFileTooLarge = function (file, size) {
 
 // [function]
 
-const packagePathReserved = function (folder) {
+// `name` is a folder when it ends with "/": the reserved folder, which a
+// build may load from, or the media folder. A file is the manifest.
+const packagePathReserved = function (name) {
   return blocks(
-    `'${folder}/' is reserved for ${TITLE}.`,
-    "Rename the folder, and the paths that load from it.",
+    `'${name}' is reserved for ${TITLE}.`,
+    name.toLowerCase() === `${HANDLE}/`
+      ? "Rename the folder, and the paths that load from it."
+      : `${TITLE} adds its own, so leave it out of the folder you pack.`,
   );
 };
 
@@ -858,10 +889,13 @@ const tagPushed = function (tag) {
 
 // [function]
 
-const templateUnavailable = function (template) {
+// `starter` is the starter its name suggests.
+const templateUnavailable = function (template, starter) {
   return blocks(
     `Unable to download template ${template}.`,
-    "Check that it's a public GitHub repository, or a folder in one.",
+    starter
+      ? `Did you mean: ${starter}?`
+      : "Check that it's a public GitHub repository, or a folder in one.",
   );
 };
 

package/src/serve/page.js

@@ -97,10 +97,10 @@ const html = function (game) {
             version: config.version,
           });
         } catch (err) {
-          console.error("arcadible: no host for the game:", err);
+          console.error("Arcadible SDK: the play page couldn't host the game, so it stands alone.", err);
         }
       } else {
-        console.error("arcadible: no host for the game: the play page's host didn't load.");
+        console.error("Arcadible SDK: the play page's host didn't load, so the game stands alone.");
       }
       frame.src = config.src;
       document.body.prepend(frame);

package/src/util/rc.js

@@ -75,7 +75,22 @@ const files = function (cmd, argv) {
 
 // [function]
 
-// a file's sections, INI or JSON, or nothing when it can't be read. JSON
+// ini parses anything, so a section header with no closing bracket, such as
+// `[validate`, would become a key, and the options under it would be read
+// outside their section. The first one's problem, or null.
+const unclosedSection = function (str) {
+  const lines = str.split(/\r?\n/u).map((line) => line.trim());
+  const i = lines.findIndex(
+    (text) => text.startsWith("[") && !/^\[[^\]]*\]$/u.test(text),
+  );
+  return i === -1
+    ? null
+    : `Line ${i + 1}: section header isn't closed: ${lines[i]}`;
+};
+
+// [function]
+
+// a file's sections, INI or JSON, or nothing when it can't be read. A file
 // that doesn't parse is `parse_failed`, naming the file.
 const read = function (file) {
   let str = null;
@@ -85,6 +100,13 @@ const read = function (file) {
     return {};
   }
   if (!/^\s*\{/u.test(str)) {
+    const unclosed = unclosedSection(str);
+    if (unclosed) {
+      throw new ArcError(
+        cfgcode.PARSE_FAILED,
+        phrase.unableToParse(file, unclosed),
+      );
+    }
     return ini.parse(str);
   }
   try {

package/src/util/s3.js

@@ -17,13 +17,32 @@ const ArcError = error.ArcError;
 const createReadStream = fs.createReadStream;
 const request = https.request;
 
+// [declare]
+
+const CHECKSUM = "x-amz-checksum-sha256";
+
+// [function]
+
+// [function]
+
+// whether the upload link signs `header`, which must then be sent.
+const signs = function (url, header) {
+  const signed = new URL(url).searchParams.get("X-Amz-SignedHeaders");
+  return Boolean(signed?.split(";").includes(header));
+};
+
 // [function]
 
-const requestOpts = function (size) {
+// the zip's SHA-256 is sent when the link signs it, so S3 refuses a zip that
+// isn't the one the upload was asked for.
+const requestOpts = function (url, { sha256, size }) {
   return {
     headers: {
       "Content-Length": size,
       "Content-Type": "application/zip",
+      ...(signs(url, CHECKSUM)
+        ? { [CHECKSUM]: Buffer.from(sha256, "hex").toString("base64") }
+        : {}),
     },
     method: "PUT",
   };
@@ -34,9 +53,9 @@ const requestOpts = function (size) {
 // puts the file to the upload link, and resolves once S3 accepts it. A
 // request that gets no response rejects as api_unreachable; a file that can't
 // be read rejects with its own error.
-const upload = function (url, { path, size }, onProgress) {
+const upload = function (url, { path, sha256, size }, onProgress) {
   return new Promise((resolve, reject) => {
-    const req = request(url, requestOpts(size), (resp) => {
+    const req = request(url, requestOpts(url, { sha256, size }), (resp) => {
       resp.resume();
       const status = resp.statusCode;
       if (status >= 200 && status < 300) {