repohub-cli 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soumya Mandal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,78 @@
-# Temporary Holding Version
+# repohub-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Command-line client for **RepoHub**, a GitHub-style platform. Version-control a folder on your laptop and sync its commits with your RepoHub account.
+
+```
+repohub login → init → add → commit → push
+```
+
+## Install
+
+Requires Node.js 18 or newer.
+
+```bash
+npm install -g repohub-cli
+repohub --help
+```
+
+Or run it without installing: `npx repohub-cli --help`
+
+## Quick start
+
+1. Create an account and a repository on the RepoHub website. Remember the repository name.
+2. Make a folder **with exactly the same name** and open it in a terminal:
+
+```bash
+mkdir my-project && cd my-project
+
+repohub login                      # asks for email and password (the password is hidden)
+repohub init
+repohub add index.js README.md     # one or more files
+repohub commit "first commit"
+repohub push
+```
+
+Open the repository on the website and look at the **Commits** and **Files** tabs.
+
+On another computer:
+
+```bash
+mkdir my-project && cd my-project
+repohub login
+repohub pull                       # downloads the commits
+repohub revert <commitId>          # copies that commit's files into the folder
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `repohub login` | Logs in and saves a token in `~/.repohub/config.json` |
+| `repohub logout` | Deletes the saved token |
+| `repohub init` | Creates the hidden `.apnaGit` folder in the current directory |
+| `repohub add <files...>` | Copies files into the staging area |
+| `repohub commit "<message>"` | Saves a snapshot of everything in the staging area |
+| `repohub push` | Uploads your commits (only to repositories you own) |
+| `repohub pull` | Downloads commits you don't have yet (your repos, or public ones) |
+| `repohub revert <commitId>` | Copies the commit's files back into the current folder |
+
+### Options
+
+- `repohub login --server <url>`: use a different RepoHub backend.
+- `REPOHUB_API_URL`: same, as an environment variable.
+- `--email` / `--password` can be passed to `login` for scripts. Prefer the prompt: a password typed on the command line stays in your shell history.
+
+## Good to know
+
+- **The folder name must equal the repository name.** That is how the CLI knows where to push.
+- Files are added **flat** (only the file name is kept, not its folder path). Folders cannot be added.
+- Staged files stay staged: every commit is a snapshot of *all* files you have added so far. Run `repohub add` again after editing a file.
+- `push` sends every local commit each time; commits already on the server are simply overwritten with the same data.
+- A commit can hold roughly 7 MB of files.
+- `revert` overwrites files with the same name and never deletes anything.
+- Your login token expires after one day; run `repohub login` again when asked.
+- If the server has been idle it can take up to a minute to wake up. The CLI waits.
+
+## License
+
+MIT

package/bin/repohub.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+const yargs = require("yargs");
+const { hideBin } = require("yargs/helpers");
+
+const { login } = require("../src/commands/login");
+const { logout } = require("../src/commands/logout");
+const { init } = require("../src/commands/init");
+const { add } = require("../src/commands/add");
+const { commit } = require("../src/commands/commit");
+const { push } = require("../src/commands/push");
+const { pull } = require("../src/commands/pull");
+const { revert } = require("../src/commands/revert");
+
+yargs(hideBin(process.argv))
+  .scriptName("repohub")
+  .command(
+    "login",
+    "Log in to RepoHub (asks for email and password if not given)",
+    (y) =>
+      y
+        .option("email", { type: "string", describe: "Your account email" })
+        .option("password", { type: "string", describe: "Your password (prefer the hidden prompt)" })
+        .option("server", { type: "string", describe: "Backend URL, if not the default" }),
+    (argv) => login(argv)
+  )
+  .command("logout", "Forget the saved login", {}, () => logout())
+  .command("init", "Start tracking the current folder", {}, () => init())
+  .command(
+    "add <files..>",
+    "Add files to the staging area",
+    (y) => y.positional("files", { describe: "Files to add", type: "string" }),
+    (argv) => add(argv.files)
+  )
+  .command(
+    "commit <message>",
+    "Save a snapshot of the staged files",
+    (y) => y.positional("message", { describe: "Commit message", type: "string" }),
+    (argv) => commit(argv.message)
+  )
+  .command("push", "Upload your commits to RepoHub", {}, () => push())
+  .command("pull", "Download commits you don't have yet", {}, () => pull())
+  .command(
+    "revert <commitId>",
+    "Copy a commit's files back into this folder",
+    (y) => y.positional("commitId", { describe: "Commit ID", type: "string" }),
+    (argv) => revert(argv.commitId)
+  )
+  .demandCommand(1, "Run `repohub <command>`. Try `repohub --help`.")
+  .strict()
+  .help()
+  .version()
+  .parse();

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "repohub-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Command-line client for RepoHub: init, add, commit, push, pull and revert",
+  "bin": {
+    "repohub": "bin/repohub.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublishOnly": "node scripts/check-server-url.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "yargs": "^17.7.3"
+  },
+  "keywords": [
+    "cli",
+    "version-control",
+    "git",
+    "repohub"
+  ],
+  "license": "MIT"
+}

package/src/authStore.js

@@ -0,0 +1,34 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const dir = () => path.join(os.homedir(), ".repohub");
+const file = () => path.join(dir(), "config.json");
+
+// Saved by `repohub login`: { token, userId, email, apiUrl }
+function saveAuth(data) {
+  fs.mkdirSync(dir(), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(file(), JSON.stringify(data, null, 2), { mode: 0o600 });
+  try {
+    fs.chmodSync(file(), 0o600); // only you can read your token (no effect on Windows)
+  } catch {}
+}
+
+function getAuth() {
+  try {
+    return JSON.parse(fs.readFileSync(file(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function clearAuth() {
+  try {
+    fs.unlinkSync(file());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { saveAuth, getAuth, clearAuth };

package/src/commands/add.js

@@ -0,0 +1,31 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { REPO_DIR } = require("../config");
+const { fail } = require("../ui");
+
+async function add(filePaths) {
+  const stagingPath = path.resolve(process.cwd(), REPO_DIR, "staging");
+
+  try {
+    await fs.mkdir(stagingPath, { recursive: true });
+
+    for (const filePath of filePaths) {
+      const stat = await fs.stat(filePath).catch(() => null);
+      if (!stat) {
+        fail(`File not found: ${filePath}`);
+        continue;
+      }
+      if (!stat.isFile()) {
+        fail(`Not a file (folders are not supported): ${filePath}`);
+        continue;
+      }
+      const fileName = path.basename(filePath);
+      await fs.copyFile(filePath, path.join(stagingPath, fileName));
+      console.log(`File ${fileName} added to the staging area!`);
+    }
+  } catch (err) {
+    fail(`Error adding file: ${err.message}`);
+  }
+}
+
+module.exports = { add };

package/src/commands/commit.js

@@ -0,0 +1,38 @@
+const fs = require("fs").promises;
+const path = require("path");
+const crypto = require("crypto");
+const { REPO_DIR } = require("../config");
+const { fail } = require("../ui");
+
+async function commit(message) {
+  const repoPath = path.resolve(process.cwd(), REPO_DIR);
+  const stagedPath = path.join(repoPath, "staging");
+
+  try {
+    // Look at the staging area first, so a failed commit leaves nothing behind
+    const entries = await fs.readdir(stagedPath, { withFileTypes: true }).catch(() => []);
+    const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+    if (files.length === 0) {
+      return fail("Nothing staged. Run `repohub add <file>` first.");
+    }
+
+    const commitID = crypto.randomUUID();
+    const commitDir = path.join(repoPath, "commits", commitID);
+    await fs.mkdir(commitDir, { recursive: true });
+
+    for (const file of files) {
+      await fs.copyFile(path.join(stagedPath, file), path.join(commitDir, file));
+    }
+
+    await fs.writeFile(
+      path.join(commitDir, "commit.json"),
+      JSON.stringify({ message, date: new Date().toISOString() })
+    );
+
+    console.log(`Commit ${commitID} created with message: ${message}`);
+  } catch (err) {
+    fail(`Error committing files: ${err.message}`);
+  }
+}
+
+module.exports = { commit };

package/src/commands/init.js

@@ -0,0 +1,20 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { REPO_DIR } = require("../config");
+const { fail } = require("../ui");
+
+async function init() {
+  const repoPath = path.resolve(process.cwd(), REPO_DIR);
+
+  try {
+    const existed = await fs.access(repoPath).then(() => true, () => false);
+    await fs.mkdir(path.join(repoPath, "commits"), { recursive: true });
+
+    console.log(existed ? "Repository already initialised." : "Repository initialised!");
+    console.log(`Reminder: this folder must be named exactly like your repository on RepoHub ("${path.basename(process.cwd())}").`);
+  } catch (err) {
+    fail(`Error initialising repository: ${err.message}`);
+  }
+}
+
+module.exports = { init };

package/src/commands/login.js

@@ -0,0 +1,40 @@
+const { DEFAULT_API_URL } = require("../config");
+const { saveAuth } = require("../authStore");
+const { request, networkErrorMessage } = require("../http");
+const { ask, closePrompts } = require("../prompt");
+const { fail } = require("../ui");
+
+async function login({ email, password, server }) {
+  const apiUrl = (server || process.env.REPOHUB_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+
+  if (/YOUR-BACKEND/.test(apiUrl)) {
+    return fail("No server configured. Use: repohub login --server https://your-backend.example.com");
+  }
+
+  // Ask for whatever was not given as a flag (the password is never echoed)
+  try {
+    if (!email) email = (await ask("Email: ")).trim();
+    if (!password) password = await ask("Password: ", { hidden: true });
+  } finally {
+    closePrompts();
+  }
+  if (!email || !password) return fail("Email and password are required.");
+
+  try {
+    const res = await request(`${apiUrl}/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password }),
+    });
+    const data = await res.json().catch(() => ({}));
+
+    if (!res.ok) return fail(data.message || "Login failed!");
+
+    saveAuth({ token: data.token, userId: data.userId, email, apiUrl });
+    console.log(`Logged in as ${email} (${apiUrl})`);
+  } catch (err) {
+    fail(networkErrorMessage(err));
+  }
+}
+
+module.exports = { login };

package/src/commands/logout.js

@@ -0,0 +1,7 @@
+const { clearAuth } = require("../authStore");
+
+function logout() {
+  console.log(clearAuth() ? "Logged out." : "You were not logged in.");
+}
+
+module.exports = { logout };

package/src/commands/pull.js

@@ -0,0 +1,103 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { REPO_DIR } = require("../config");
+const { getAuth } = require("../authStore");
+const { request, networkErrorMessage } = require("../http");
+const { fail } = require("../ui");
+
+const COMMIT_ID = /^[A-Za-z0-9-]{8,64}$/;
+
+// Never trust names coming from the network: no folders, no "." / ".."
+function isSafeName(name) {
+  return (
+    typeof name === "string" &&
+    name.length > 0 &&
+    !/[\\/]/.test(name) &&
+    name !== "." &&
+    name !== ".."
+  );
+}
+
+async function pull() {
+  const auth = getAuth();
+  if (!auth) {
+    return fail("You are not logged in. Run: repohub login");
+  }
+
+  // Folder name = repository name on the website
+  const repoName = path.basename(process.cwd());
+  const commitsPath = path.resolve(process.cwd(), REPO_DIR, "commits");
+  const headers = { Authorization: `Bearer ${auth.token}` };
+
+  try {
+    // 1. Find the repository on the server
+    const repoRes = await request(
+      `${auth.apiUrl}/repo/name/${encodeURIComponent(repoName)}`,
+      { headers }
+    );
+    if (repoRes.status === 401) {
+      return fail("Session expired. Run `repohub login` again.");
+    }
+    if (repoRes.status === 404) {
+      return fail(`No repository named "${repoName}" on RepoHub.`);
+    }
+    if (!repoRes.ok) {
+      const body = await repoRes.json().catch(() => ({}));
+      return fail(`Could not find the repository: ${body.error || repoRes.status}`);
+    }
+    const repo = await repoRes.json();
+
+    // 2. List the commits that exist on the server
+    const listRes = await request(`${auth.apiUrl}/repo/${repo._id}/commits`, { headers });
+    if (!listRes.ok) {
+      const body = await listRes.json().catch(() => ({}));
+      return fail(`Could not list commits: ${body.error || listRes.status}`);
+    }
+    const commits = await listRes.json();
+    if (commits.length === 0) {
+      console.log("Nothing to pull. There are no commits on the server yet.");
+      return;
+    }
+
+    await fs.mkdir(commitsPath, { recursive: true });
+
+    // 3. Download every commit we don't already have (commits never change)
+    let pulled = 0;
+    let skipped = 0;
+    for (const { commitId } of commits) {
+      if (!COMMIT_ID.test(commitId)) continue;
+
+      const commitDir = path.join(commitsPath, commitId);
+      const exists = await fs.access(commitDir).then(() => true, () => false);
+      if (exists) {
+        skipped++;
+        continue;
+      }
+
+      const res = await request(`${auth.apiUrl}/repo/${repo._id}/commits/${commitId}`, { headers });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        console.error(`Commit ${commitId} failed: ${err.error || res.status}`);
+        process.exitCode = 1;
+        continue;
+      }
+      const { files } = await res.json();
+
+      await fs.mkdir(commitDir, { recursive: true });
+      for (const f of files) {
+        if (!isSafeName(f.name)) {
+          console.error(`Skipped unsafe file name: ${f.name}`);
+          continue;
+        }
+        await fs.writeFile(path.join(commitDir, f.name), Buffer.from(f.content, "base64"));
+      }
+      pulled++;
+    }
+
+    console.log(`Pulled ${pulled} new commit(s), ${skipped} already up to date.`);
+  } catch (err) {
+    fail(networkErrorMessage(err));
+  }
+}
+
+module.exports = { pull };

package/src/commands/push.js

@@ -0,0 +1,88 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { REPO_DIR } = require("../config");
+const { getAuth } = require("../authStore");
+const { request, networkErrorMessage } = require("../http");
+const { fail } = require("../ui");
+
+async function push() {
+  const auth = getAuth();
+  if (!auth) {
+    return fail("You are not logged in. Run: repohub login");
+  }
+
+  // Folder name = repository name on the website
+  const repoName = path.basename(process.cwd());
+  const commitsPath = path.resolve(process.cwd(), REPO_DIR, "commits");
+  const headers = {
+    Authorization: `Bearer ${auth.token}`,
+    "Content-Type": "application/json",
+  };
+
+  try {
+    // 1. Find the repository on the server
+    const repoRes = await request(
+      `${auth.apiUrl}/repo/name/${encodeURIComponent(repoName)}`,
+      { headers }
+    );
+    if (repoRes.status === 401) {
+      return fail("Session expired. Run `repohub login` again.");
+    }
+    if (repoRes.status === 404) {
+      return fail(`No repository named "${repoName}" on RepoHub. Create it on the website with exactly this name.`);
+    }
+    if (!repoRes.ok) {
+      const body = await repoRes.json().catch(() => ({}));
+      return fail(`Could not find the repository: ${body.error || repoRes.status}`);
+    }
+    const repo = await repoRes.json();
+    if (String(repo.owner?._id) !== String(auth.userId)) {
+      return fail(`"${repoName}" belongs to someone else. You can only push to your own repositories.`);
+    }
+
+    // 2. Read local commits
+    let commitDirs;
+    try {
+      commitDirs = await fs.readdir(commitsPath);
+    } catch {
+      return fail("Nothing to push. Run `repohub init`, `repohub add` and `repohub commit` first.");
+    }
+    if (commitDirs.length === 0) {
+      return fail("No commits to push.");
+    }
+
+    // 3. Send each commit to the backend
+    let pushed = 0;
+    for (const commitId of commitDirs) {
+      const commitPath = path.join(commitsPath, commitId);
+      const entries = await fs.readdir(commitPath, { withFileTypes: true });
+
+      const files = [];
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        const buf = await fs.readFile(path.join(commitPath, entry.name));
+        files.push({ name: entry.name, content: buf.toString("base64") });
+      }
+
+      const res = await request(`${auth.apiUrl}/repo/${repo._id}/commits/${commitId}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ files }),
+      });
+
+      if (res.ok) {
+        pushed++;
+      } else {
+        const err = await res.json().catch(() => ({}));
+        console.error(`Commit ${commitId} failed: ${err.error || res.status}`);
+        process.exitCode = 1;
+      }
+    }
+
+    console.log(`Pushed ${pushed} of ${commitDirs.length} commit(s) to "${repoName}".`);
+  } catch (err) {
+    fail(networkErrorMessage(err));
+  }
+}
+
+module.exports = { push };

package/src/commands/revert.js

@@ -0,0 +1,32 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { REPO_DIR } = require("../config");
+const { fail } = require("../ui");
+
+const COMMIT_ID = /^[A-Za-z0-9-]{8,64}$/;
+
+async function revert(commitId) {
+  if (!COMMIT_ID.test(commitId)) {
+    return fail("Invalid commit ID.");
+  }
+
+  const commitDir = path.resolve(process.cwd(), REPO_DIR, "commits", commitId);
+
+  try {
+    const entries = await fs.readdir(commitDir, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      return fail(`Commit ${commitId} not found in this folder. Try \`repohub pull\` first.`);
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name === "commit.json") continue; // commit.json is metadata
+      await fs.copyFile(path.join(commitDir, entry.name), path.resolve(process.cwd(), entry.name));
+    }
+
+    console.log(`Commit ${commitId} reverted successfully!`);
+  } catch (err) {
+    fail(`Unable to revert: ${err.message}`);
+  }
+}
+
+module.exports = { revert };

package/src/config.js

@@ -0,0 +1,11 @@
+// The backend the CLI talks to unless the user passes --server
+// (or sets REPOHUB_API_URL). Replace with your deployed backend URL before publishing.
+const DEFAULT_API_URL = "https://repohub-backend-gakq.onrender.com";
+
+// Free hosting can take ~30-60 s to wake up, so be patient before giving up.
+const TIMEOUT_MS = Number(process.env.REPOHUB_TIMEOUT_MS) || 90000;
+
+// Hidden folder created inside a project by `repohub init`
+const REPO_DIR = ".apnaGit";
+
+module.exports = { DEFAULT_API_URL, TIMEOUT_MS, REPO_DIR };

package/src/http.js

@@ -0,0 +1,29 @@
+const { TIMEOUT_MS } = require("./config");
+
+// fetch() with a timeout, so the CLI never hangs forever
+function request(url, options = {}) {
+  return fetch(url, { ...options, signal: AbortSignal.timeout(TIMEOUT_MS) });
+}
+
+// Turn a low-level network error into a sentence a person can act on
+function networkErrorMessage(err) {
+  if (err.name === "TimeoutError") {
+    return "The server took too long to respond. If it was idle it may still be waking up, try again in a minute.";
+  }
+
+  // The real reason is hidden inside err.cause (sometimes inside an AggregateError)
+  const cause = err.cause;
+  const reason =
+    (cause && (cause.code || (cause.errors && cause.errors[0] && cause.errors[0].code))) ||
+    err.message;
+
+  let hint = "";
+  if (reason === "ENOTFOUND" || reason === "EAI_AGAIN") {
+    hint = " Check your internet connection and the server address.";
+  } else if (reason === "ECONNREFUSED") {
+    hint = " The server is not running or the address is wrong.";
+  }
+  return `Could not reach the server (${reason}).${hint}`;
+}
+
+module.exports = { request, networkErrorMessage };

package/src/prompt.js

@@ -0,0 +1,66 @@
+const readline = require("readline");
+
+// ---- piped / non-interactive input: read one line at a time ----
+let rl;
+let lines;
+function nextLine() {
+  if (!rl) {
+    rl = readline.createInterface({ input: process.stdin });
+    lines = rl[Symbol.asyncIterator]();
+  }
+  return lines.next().then((r) => (r.done ? "" : r.value));
+}
+
+// ---- real terminal: read characters ourselves so a password is never echoed ----
+function readFromTerminal(question, hidden) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    // Switch to raw mode BEFORE showing the prompt, so nothing typed
+    // right away can be echoed by the terminal.
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    process.stdout.write(question);
+
+    let input = "";
+    const finish = (value) => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stdout.write("\n");
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") return finish(input);
+        if (ch === "\u0003") {            // Ctrl+C
+          stdin.setRawMode(false);
+          process.stdout.write("\n");
+          process.exit(130);
+        }
+        if (ch === "\u007f" || ch === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            if (!hidden) process.stdout.write("\b \b");
+          }
+        } else if (ch >= " ") {
+          input += ch;
+          if (!hidden) process.stdout.write(ch);
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+async function ask(question, { hidden = false } = {}) {
+  if (process.stdin.isTTY) return readFromTerminal(question, hidden);
+  process.stdout.write(question);
+  return nextLine();
+}
+
+function closePrompts() {
+  if (rl) rl.close();
+}
+
+module.exports = { ask, closePrompts };

package/src/ui.js

@@ -0,0 +1,7 @@
+// Print an error and make the process exit with a non-zero code (useful in scripts).
+function fail(message) {
+  console.error(message);
+  process.exitCode = 1;
+}
+
+module.exports = { fail };