arcadible 0.1.1 → 0.1.2

package/bin/arc-default.js

@@ -35,7 +35,6 @@ const main = function (argv) {
       .command("inspect", "Inspect project metadata")
       .command("login", "Log in to Arcadible")
       .command("logout", "Log out of Arcadible")
-      .command("pack", "Package for distribution")
       .command("validate", "Validate workspace")
       .command("whoami", "Show current account")
       .help("help")

package/bin/arc-deploy.js

@@ -17,6 +17,7 @@ const log = require("../src/util/log");
 const output = require("../src/util/output");
 const pkg = require("../package.json");
 const rc = require("../src/util/rc");
+const validate = require("../src/cli/validate");
 
 // [use]
 
@@ -32,7 +33,6 @@ const SUBCMD = "deploy";
 // [define]
 
 const conf = {
-  git: false,
   json: false,
   production: false,
   quiet: false,
@@ -41,24 +41,69 @@ const conf = {
 
 // [function]
 
+const handler = function ({ json, quiet }) {
+  return {
+    onBegin() {
+      if (!json && !quiet) {
+        log.p("Deploying project...");
+      }
+    },
+    onInfo({ level, message }) {
+      if (json || quiet) {
+        return;
+      }
+      switch (level) {
+        case "warn":
+          log.pw(`⚠ ${message}`);
+          return;
+        default:
+          log.p(`• ${message}`);
+      }
+    },
+  };
+};
+
+// [function]
+
 const start = function (argv) {
   const json = argv.json;
-  return deploy({
-    git: argv.git,
-    pre: !argv.production,
-    preId: "rc",
-    quiet: argv.quiet,
-    root: resolve(process.cwd(), argv.cwd),
-  }).catch((ex) => {
-    const message = ex.message;
-    if (json) {
-      print({ error: { message } });
-    } else {
-      log.hd("Deploy aborted.");
-      log.p(message);
-    }
-    process.exit(1);
-  });
+  const pre = !argv.production;
+  const quiet = argv.quiet;
+  const root = resolve(process.cwd(), argv.cwd);
+  return validate({ root })
+    .then((issues) => {
+      const valid = !issues.length;
+      if (!valid) {
+        throw new Error("Validate failed. Run `arc validate` for details.");
+      }
+      return deploy({
+        direct: false,
+        handler: handler({ json, quiet }),
+        pre,
+        preId: "rc",
+        root,
+      });
+    })
+    .then((data) => {
+      if (json) {
+        print({ version: data });
+        return;
+      }
+      if (!quiet) {
+        log.p(`✓ ${pre ? "Prerelease" : "Release"} v${data.to} submitted.`);
+        log.hs("Deployed.");
+      }
+    })
+    .catch((ex) => {
+      const message = ex.message;
+      if (json) {
+        print({ error: { message } });
+      } else {
+        log.hd("Deploy aborted.");
+        log.p(message);
+      }
+      process.exit(1);
+    });
 };
 
 // [function]
@@ -74,11 +119,6 @@ const main = function (argv) {
         describe: "Deploy to production.",
         type: "boolean",
       })
-      .option("git", {
-        default: conf.git,
-        describe: "Deploy using Git.",
-        type: "boolean",
-      })
       .option("json", {
         alias: "j",
         default: conf.json,

package/bin/arc-init.js

@@ -20,7 +20,7 @@ const output = require("../src/util/output");
 const pkg = require("../package.json");
 const project = require("../src/prompt/project");
 const rc = require("../src/util/rc");
-const template = require("../src/prompt/template");
+const starter = require("../src/prompt/starter");
 
 // [use]
 
@@ -70,7 +70,7 @@ const start = function (argv) {
     handler: handler({ json, quiet }),
     project: argv.project,
     root,
-    template: argv.template,
+    starter: argv.starter,
   })
     .then((data) => {
       const dir = relative(root, data.path);
@@ -110,14 +110,14 @@ const prompt = async function ({ yes, ...argv }) {
   const opts = { ...argv };
   if (yes) {
     opts.project ??= project.input.default;
-    opts.template ??= template.select.default;
+    opts.starter ??= starter.select.default;
     return opts;
   }
   if (!argv.project) {
     opts.project = await input(project.input);
   }
-  if (!argv.template) {
-    opts.template = await select(template.select);
+  if (!argv.starter) {
+    opts.starter = await select(starter.select);
   }
   return opts;
 };
@@ -135,9 +135,9 @@ const main = function (argv) {
           type: "string",
         }),
       )
-      .option("template", {
+      .option("starter", {
         alias: "t",
-        describe: "Select a project template.",
+        describe: "Select a project starter.",
         type: "string",
       })
       .option("yes", {

package/bin/arc-pack.js

@@ -49,7 +49,7 @@ const start = function (argv) {
     .then((issues) => {
       const valid = !issues.length;
       if (!valid) {
-        throw new Error("Validation failed. Run `arc validate` for details.");
+        throw new Error("Validate failed. Run `arc validate` for details.");
       }
       return pack({ output: argv.output, root });
     })
@@ -60,7 +60,6 @@ const start = function (argv) {
       }
       if (!quiet) {
         log.hs("Packed.");
-        print(data, { toml: true });
       }
     })
     .catch((ex) => {

package/bin/arc-validate.js

@@ -44,18 +44,19 @@ const start = function (argv) {
   const quiet = argv.quiet;
   return validate({ root: resolve(process.cwd(), argv.cwd) })
     .then((issues) => {
-      const valid = !issues.length;
+      const count = issues.length;
+      const term = count === 1 ? "issue" : "issues";
       if (json) {
         print({ issues });
-      } else if (valid) {
-        if (!quiet) {
-          log.hs("Passed.");
+      } else if (!quiet) {
+        if (count) {
+          log.hd(`${count} ${term} found.`);
+          log.p(issues.map((error) => `✗ ${error}`));
+        } else {
+          log.hs("Validated.");
         }
-      } else {
-        log.hd("Failed.");
-        log.p(issues.map((error) => `✖ ${error}`));
       }
-      process.exit(valid ? 0 : 1);
+      process.exit(count ? 1 : 0);
     })
     .catch((ex) => {
       const message = ex.message;

package/package.json

@@ -18,6 +18,7 @@
     "degit": "^2.8.6",
     "dompurify": "^3.3.1",
     "dot-prop": "^6.0.1",
+    "fast-json-stable-stringify": "^2.1.0",
     "fs-extra": "^11.3.2",
     "image-size": "^2.0.2",
     "jsdom": "^27.3.0",
@@ -25,6 +26,7 @@
     "mp4box": "^2.3.0",
     "open": "^8.4.2",
     "rc": "^1.2.8",
+    "semver": "^7.7.3",
     "yargs": "^17.7.2",
     "zod": "^4.1.13"
   },
@@ -49,5 +51,5 @@
   "license": "Apache-2.0",
   "main": "./src/cli/index.js",
   "name": "arcadible",
-  "version": "0.1.1"
+  "version": "0.1.2"
 }

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

@@ -4,20 +4,189 @@
 
 const execFile = require("node:child_process").execFile;
 
+// [import]
+
+const semver = require("semver");
+
+// [import]
+
+const strs = require("../../util/strs");
+
+// [use]
+
+const compareSemver = semver.compare;
+const trimWhitespace = strs.trimWhitespace;
+const validSemver = semver.valid;
+
+// [declare]
+
+const PREFIX = "arcadible/release/v";
+
+// [function]
+
+const git = function (root, args, cb) {
+  execFile("git", ["-C", root, ...args], cb);
+};
+
+// [function]
+
+const ensureRepo = function (root, cb) {
+  const message = [
+    "Unable to find Git repository.",
+    "Run this command from a Git repository.",
+  ];
+  git(root, ["rev-parse", "--is-inside-work-tree"], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
+// [function]
+
+const ensureRemote = function (root, cb) {
+  const message = [
+    "Unable to access Git remote 'origin'.",
+    "Verify the remote exists and you have permission to access it.",
+  ];
+  git(root, ["ls-remote", "origin"], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
 // [function]
 
-const isDirty = function (root, cb) {
-  execFile("git", ["-C", root, "diff", "--quiet"], (err) => {
+const ensureClean = function (root, cb) {
+  const message = [
+    "Unable to continue with unstaged changes.",
+    "Stage, commit, or discard local changes before deploying.",
+  ];
+  git(root, ["diff", "--quiet"], (err) => {
     if (err) {
-      cb(true);
+      if (err.code === 1) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb(err);
       return;
     }
-    execFile("git", ["-C", root, "diff", "--cached", "--quiet"], (err) => {
-      cb(Boolean(err));
+    git(root, ["diff", "--cached", "--quiet"], (err) => {
+      if (!err) {
+        cb(null, { cached: false });
+        return;
+      }
+      if (err.code === 1) {
+        cb(null, { cached: true });
+        return;
+      }
+      cb(err);
     });
   });
 };
 
+// [function]
+
+const fetchTags = function (root, cb) {
+  const message = [
+    "Unable to synchronize Git release tags.",
+    "Run `arc deploy` again to retry with the latest release tags.",
+  ];
+  git(
+    root,
+    ["fetch", "origin", `refs/tags/${PREFIX}*:refs/tags/${PREFIX}*`],
+    (err) => {
+      if (err) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb();
+    },
+  );
+};
+
+// [function]
+
+const listTags = function (root, cb) {
+  fetchTags(root, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    git(root, ["tag", "--list", `${PREFIX}*`], (err, stdOut) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      const versions = trimWhitespace(stdOut)
+        .split("\n")
+        .map((tag) => tag.slice(PREFIX.length))
+        .filter(validSemver)
+        .sort(compareSemver);
+      cb(null, versions.at(-1) || "0.0.0");
+    });
+  });
+};
+
+// [function]
+
+const createTag = function (root, version, pre, cb) {
+  const message = [
+    "Unable to create Git tag.",
+    "Verify the release tag does not already exist locally.",
+  ];
+  git(
+    root,
+    [
+      "tag",
+      "-a",
+      `${PREFIX}${version}`,
+      "-m",
+      pre ? `Prerelease v${version}` : `Release v${version}`,
+    ],
+    (err) => {
+      if (err) {
+        cb(new Error(message.join("\n"), { cause: err }));
+        return;
+      }
+      cb();
+    },
+  );
+};
+
+// [function]
+
+const pushTag = function (root, version, cb) {
+  const message = [
+    "Unable to push Git tag.",
+    "Run `arc deploy` again to retry with the latest release version.",
+  ];
+  git(root, ["push", "origin", `${PREFIX}${version}`], (err) => {
+    if (err) {
+      cb(new Error(message.join("\n"), { cause: err }));
+      return;
+    }
+    cb();
+  });
+};
+
+// [function]
+
+const release = function (root, version, pre, cb) {
+  createTag(root, version, pre, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    pushTag(root, version, cb);
+  });
+};
+
 // [export]
 
-module.exports = { isDirty };
+module.exports = { ensureClean, ensureRemote, ensureRepo, listTags, release };

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

@@ -1,9 +1,84 @@
 "use strict";
 
+// [import]
+
+const semver = require("semver");
+
+// [import]
+
+const git = require("./git");
+
+// [use]
+
+const ensureClean = git.ensureClean;
+const ensureRemote = git.ensureRemote;
+const ensureRepo = git.ensureRepo;
+const incSemver = semver.inc;
+const listTags = git.listTags;
+const release = git.release;
+
+// [function]
+
+const deployGit = function ({ pre, preId, root }, handler, cb) {
+  listTags(root, (err, from) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    const to = incSemver(from, pre ? "prerelease" : "patch", preId);
+    release(root, to, pre, (err) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      cb(null, { from, to });
+    });
+  });
+};
+
+// [function]
+
+const deploy = function ({ pre, preId, root }, { onInfo }, cb) {
+  ensureRepo(root, (err) => {
+    if (err) {
+      cb(err);
+      return;
+    }
+    ensureClean(root, (err, diff) => {
+      if (err) {
+        cb(err);
+        return;
+      }
+      if (diff.cached) {
+        onInfo({
+          level: "warn",
+          message: "Staged but uncommitted changes will not be deployed.",
+        });
+      }
+      ensureRemote(root, (err) => {
+        if (err) {
+          cb(err);
+          return;
+        }
+        deployGit({ pre, preId, root }, { onInfo }, cb);
+      });
+    });
+  });
+};
+
 // [function]
 
-const main = function () {
-  return Promise.reject(new Error("Unimplemented command."));
+const main = function ({ pre, preId, root }, { onBegin, ...handler }) {
+  onBegin({ root });
+  return new Promise((resolve, reject) => {
+    deploy({ pre, preId, root }, handler, (err, data) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(data);
+    });
+  });
 };
 
 // [export]

package/src/action/init/tool.js

@@ -27,14 +27,14 @@ const init = function (src, dest, { onBegin, onInfo }) {
 
 // [function]
 
-const main = function ({ force, project, root, template }, handler) {
+const main = function ({ force, project, root, starter }, handler) {
   const dest = resolve(root, project);
   return pathExists(dest)
     .then((exists) => {
       if (exists && !force) {
         throw new Error("Directory exists. Run with `--force` to overwrite.");
       }
-      return init(template, dest, handler);
+      return init(starter, dest, handler);
     })
     .then(() => ({ path: dest }));
 };

package/src/cli/deploy.js

@@ -7,9 +7,9 @@ const deployTool = require("../action/deploy/tool");
 
 // [function]
 
-const main = function ({ git, ...conf }) {
-  const tool = git ? deployGitTool : deployTool;
-  return tool(conf);
+const main = function ({ direct, handler, ...conf }) {
+  const tool = direct ? deployTool : deployGitTool;
+  return tool(conf, handler);
 };
 
 // [export]

package/src/config/workflow.js

@@ -2,4 +2,9 @@
 
 // [export]
 
-module.exports = {};
+module.exports = {
+  /* eslint-disable camelcase */
+  deploy_dir: ".arcadible-public",
+  skip_build: false,
+  /* eslint-enable camelcase */
+};

package/src/parser/manifest.js

@@ -12,6 +12,7 @@ const TOML = require("@iarna/toml");
 // [use]
 
 const join = path.join;
+const pathExists = fs.pathExists;
 const readFile = fs.readFile;
 
 // [declare]
@@ -33,12 +34,10 @@ const parseToml = function (buf) {
 // [function]
 
 const parse = function (root) {
-  return new Promise((resolve, reject) => {
-    readFile(join(root, MANIFEST), "utf8")
-      .then(parseToml)
-      .then(resolve)
-      .catch(reject);
-  });
+  const file = join(root, MANIFEST);
+  return pathExists(file)
+    .then((exists) => (exists ? readFile(file, "utf8") : null))
+    .then((buf) => (buf === null ? {} : parseToml(buf)));
 };
 
 // [export]

package/src/parser/pkg.js

@@ -0,0 +1,56 @@
+"use strict";
+
+// [import]
+
+const path = require("node:path");
+
+// [import]
+
+const fs = require("fs-extra");
+
+// [use]
+
+const join = path.join;
+const pathExists = fs.pathExists;
+const readFile = fs.readFile;
+
+// [declare]
+
+const PACKAGE = "package.json";
+
+// [function]
+
+const parseJson = function (buf) {
+  try {
+    return JSON.parse(buf);
+  } catch (ex) {
+    throw new Error(`Unable to parse ${PACKAGE}: ${ex.message}`, {
+      cause: ex,
+    });
+  }
+};
+
+// [function]
+
+const extract = function (pkg) {
+  const game = { version: pkg.version || null };
+  return Object.fromEntries(
+    Object.entries({ game }).filter(([, value]) =>
+      Object.values(value).some(Boolean),
+    ),
+  );
+};
+
+// [function]
+
+const parse = function (root) {
+  const file = join(root, PACKAGE);
+  return pathExists(file)
+    .then((exists) => (exists ? readFile(file, "utf8") : null))
+    .then((buf) => (buf === null ? {} : parseJson(buf)))
+    .then((pkg) => (Object.keys(pkg).length ? extract(pkg) : {}));
+};
+
+// [export]
+
+module.exports = { parse };

package/src/parser/project.js

@@ -6,16 +6,18 @@ const cfggame = require("../config/game");
 const cfgworkflow = require("../config/workflow");
 const manifest = require("./manifest");
 const media = require("./media");
+const pkg = require("./pkg");
 const promise = require("../util/promise");
 const readme = require("./readme");
 
 // [function]
 
-const configGame = function (readmeGame, mediaGame, manifestGame) {
+const configGame = function (readmeGame, mediaGame, pkgGame, manifestGame) {
   return {
     ...cfggame,
     ...(readmeGame || {}),
     ...(mediaGame || {}),
+    ...(pkgGame || {}),
     ...(manifestGame || {}),
   };
 };
@@ -35,14 +37,16 @@ const parse = function (root) {
   const parsers = [
     () => manifest.parse(root),
     () => media.parse(root),
+    () => pkg.parse(root),
     () => readme.parse(root),
   ];
   return promise
     .serial(parsers)
-    .then(([manifestData, mediaData, readmeData]) => {
+    .then(([manifestData, mediaData, pkgData, readmeData]) => {
       const game = configGame(
         readmeData.game,
         mediaData.game,
+        pkgData.game,
         manifestData.game,
       );
       const workflow = configWorkflow(manifestData.workflow);

package/src/parser/readme.js

@@ -18,13 +18,14 @@ const strs = require("../util/strs");
 // [use]
 
 const join = path.join;
+const pathExists = fs.pathExists;
 const pruneEmpty = objs.pruneEmpty;
 const readFile = fs.readFile;
 const trimWhitespace = strs.trimWhitespace;
 
 // [declare]
 
-const README = "README.md";
+const README = ["arcadible.md", "README.md"];
 
 // [function]
 
@@ -118,25 +119,34 @@ const extract = function (html) {
 
 // [function]
 
-const parseReadme = function (buf) {
+const parseReadme = function (buf, file) {
   try {
     return extract(MD.parse(buf));
   } catch (ex) {
-    throw new Error(`Unable to parse ${README}: ${ex.message}`, { cause: ex });
+    throw new Error(`Unable to parse ${file}: ${ex.message}`, {
+      cause: ex,
+    });
   }
 };
 
 // [function]
 
+const findReadme = function (root) {
+  return Promise.all(
+    README.map((file) =>
+      pathExists(join(root, file)).then((exists) => (exists ? file : null)),
+    ),
+  ).then((files) => files.find(Boolean) || null);
+};
+
+// [function]
+
 const parse = function (root) {
-  return new Promise((resolve, reject) => {
-    readFile(join(root, README), "utf8")
-      .then(parseReadme)
-      .then(pruneEmpty)
-      .then((game) => ({ game }))
-      .then(resolve)
-      .catch(reject);
-  });
+  return findReadme(root)
+    .then((file) => (file ? readFile(join(root, file), "utf8") : null))
+    .then((buf) => (buf === null ? null : parseReadme(buf)))
+    .then(pruneEmpty)
+    .then((game) => ({ game: game || null }));
 };
 
 // [export]

package/src/prompt/{template.js → starter.js}

@@ -1,5 +1,9 @@
 "use strict";
 
+// [declare]
+
+const REPO = "arcadible";
+
 // [export]
 
 module.exports = {
@@ -8,30 +12,30 @@ module.exports = {
       {
         description: "Blank starter template.",
         name: "Blank",
-        value: "arcadible/starter",
+        value: `${REPO}/starter`,
       },
       {
         description: "Three.js starter template.",
         name: "Three.js",
-        value: "arcadible/starter-threejs",
+        value: `${REPO}/starter-threejs`,
       },
       {
         description: "Phaser starter template.",
         name: "Phaser",
-        value: "arcadible/starter-phaser",
+        value: `${REPO}/starter-phaser`,
       },
       {
         description: "PixiJS starter template.",
         name: "PixiJS",
-        value: "arcadible/starter-pixijs",
+        value: `${REPO}/starter-pixijs`,
       },
       {
         description: "Babylon.js starter template.",
         name: "Babylon.js",
-        value: "arcadible/starter-babylonjs",
+        value: `${REPO}/starter-babylonjs`,
       },
     ],
-    default: "arcadible/starter",
-    message: "Template",
+    default: `${REPO}/starter`,
+    message: "Starter",
   },
 };

package/src/schema/game.js

@@ -3,6 +3,7 @@
 // [import]
 
 const chalk = require("chalk");
+const semver = require("semver");
 const z = require("zod");
 
 // [import]
@@ -16,6 +17,10 @@ const cfgurl = require("../config/url");
 const cfgvisibility = require("../config/visibility");
 const dom = require("../util/dom");
 
+// [use]
+
+const validSemver = semver.valid;
+
 // [function]
 
 const reference = function (field) {
@@ -267,6 +272,18 @@ const zTrailer = function () {
 
 // [function]
 
+const zVersion = function () {
+  const field = "game.version";
+  return z
+    .string()
+    .refine(
+      (value) => validSemver(value) !== null,
+      message(field, "Must be a valid semver."),
+    );
+};
+
+// [function]
+
 const zVisibility = function () {
   // const field = "game.visibility";
   return z.optional(z.enum(cfgvisibility));
@@ -312,6 +329,7 @@ const main = function (value, { root }) {
     tagline: zTagline(),
     title: zTitle(),
     trailer: zTrailer(),
+    version: zVersion(),
     visibility: zVisibility(),
     wordmark: zWordmark(root),
     wordmark_animated: zWordmarkAnimated(root),

package/src/util/log.js

@@ -72,6 +72,30 @@ const pdnl = function (message) {
 
 // [function]
 
+const hw = function (message) {
+  log(console.log, message, { bold: true, color: "yellow" });
+};
+
+// [function]
+
+const hwnl = function (message) {
+  log(console.log, message, { bold: true, color: "yellow", nl: true });
+};
+
+// [function]
+
+const pw = function (message) {
+  log(console.log, message, { color: "yellow" });
+};
+
+// [function]
+
+const pwnl = function (message) {
+  log(console.log, message, { color: "yellow", nl: true });
+};
+
+// [function]
+
 const hs = function (message) {
   log(console.log, message, { bold: true, color: "green" });
 };
@@ -96,4 +120,21 @@ const psnl = function (message) {
 
 // [export]
 
-module.exports = { h, hd, hdnl, hnl, hs, hsnl, p, pd, pdnl, pnl, ps, psnl };
+module.exports = {
+  h,
+  hd,
+  hdnl,
+  hnl,
+  hs,
+  hsnl,
+  hw,
+  hwnl,
+  p,
+  pd,
+  pdnl,
+  pnl,
+  ps,
+  psnl,
+  pw,
+  pwnl,
+};

package/src/util/objs.js

@@ -1,5 +1,9 @@
 "use strict";
 
+// [import]
+
+const stringify = require("fast-json-stable-stringify");
+
 // [function]
 
 const pruneEmpty = function (value) {
@@ -23,6 +27,12 @@ const pruneEmpty = function (value) {
   /* eslint-enable no-undefined */
 };
 
+// [function]
+
+const sort = function (value) {
+  return JSON.parse(stringify(value));
+};
+
 // [export]
 
-module.exports = { pruneEmpty };
+module.exports = { pruneEmpty, sort };

package/src/util/output.js

@@ -4,6 +4,14 @@
 
 const TOML = require("@iarna/toml");
 
+// [import]
+
+const objs = require("./objs");
+
+// [use]
+
+const sort = objs.sort;
+
 // [function]
 
 const write = function (data) {
@@ -13,7 +21,7 @@ const write = function (data) {
 // [function]
 
 const printJson = function (data) {
-  write(JSON.stringify(data, null, 2));
+  write(JSON.stringify(sort(data), null, 2));
 };
 
 // [function]
@@ -25,7 +33,7 @@ const printToml = function (data, key = "value") {
     return;
   }
   try {
-    write(TOML.stringify(data));
+    write(TOML.stringify(sort(data)));
   } catch (ex) {
     write(TOML.stringify({ [field]: data }));
   }

package/src/util/request.js

@@ -24,8 +24,8 @@ const parse = function (resp) {
 
 const send = function (method, url, body, { token } = {}) {
   const headers = {
-    "X-Arc-Id": CLIENT_ID,
-    "X-Arc-Version": CLIENT_VERSION,
+    "X-Arc-Client-Id": CLIENT_ID,
+    "X-Arc-Client-Version": CLIENT_VERSION,
   };
   if (token) {
     headers.authorization = `Bearer ${token}`;

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

@@ -1,74 +0,0 @@
-"use strict";
-
-// [import]
-
-const execFile = require("node:child_process").execFile;
-
-// [import]
-
-const strs = require("../../util/strs");
-
-// [use]
-
-const trimWhitespace = strs.trimWhitespace;
-
-// [declare]
-
-const RE_TAG_EXISTS = /tag\s+'([^']+)'\s+already\s+exists/iu;
-
-// [function]
-
-const knownErr = function (stdErr) {
-  const tagExists = stdErr.match(RE_TAG_EXISTS);
-  if (tagExists) {
-    return [
-      `Git tag exists: ${tagExists[1]}`,
-      "The package version has been synchronized.",
-      "Try again.",
-    ].join("\n");
-  }
-  return stdErr;
-};
-
-// [function]
-
-const npm = function (root, pre, preId) {
-  return [
-    "--prefix",
-    root,
-    "version",
-    pre ? "prerelease" : "patch",
-    "--preid",
-    preId,
-    "-m",
-    pre ? "Prerelease v%s" : "Release v%s",
-  ];
-};
-
-// [function]
-
-const git = function (root) {
-  return ["-C", root, "push", "--follow-tags"];
-};
-
-// [function]
-
-const main = function (root, { pre, preId }, cb) {
-  execFile("npm", npm(root, pre, preId), (err, stdOut, stdErr) => {
-    if (err) {
-      cb(new Error(knownErr(stdErr), { cause: err }));
-      return;
-    }
-    execFile("git", git(root), (err) => {
-      if (err) {
-        cb(new Error(knownErr(stdErr), { cause: err }));
-        return;
-      }
-      cb(null, trimWhitespace(stdOut));
-    });
-  });
-};
-
-// [export]
-
-module.exports = main;