aibex 0.0.0-stage → 0.0.1

package/dist/cli.js

@@ -0,0 +1,777 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { homedir } from "node:os";
+import path from "node:path";
+import { readFileSync, mkdirSync, writeFileSync, renameSync, rmSync, existsSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { createConnection } from "node:net";
+function out(line) {
+  process.stdout.write(`${line}
+`);
+}
+function error(line) {
+  process.stderr.write(`${line}
+`);
+}
+function aibexHome(env = process.env) {
+  const override = env.AIBEX_HOME;
+  return override ? path.resolve(override) : path.join(homedir(), ".aibex");
+}
+function statePaths(home) {
+  return {
+    home,
+    pidFile: path.join(home, "aibexd.pid"),
+    configFile: path.join(home, "config.json"),
+    stateFile: path.join(home, "state.json"),
+    socketFile: path.join(home, "supervisor.sock"),
+    versionsDir: path.join(home, "versions"),
+    hostsDir: path.join(home, "hosts")
+  };
+}
+const DEFAULT_PORTS = {
+  "https:": "443",
+  "http:": "80"
+};
+function hostDirectoryName(host) {
+  const url = new URL(host);
+  const port = url.port || DEFAULT_PORTS[url.protocol] || "";
+  return `${url.hostname}_${port}`.replaceAll(/[^\w.-]/g, "_");
+}
+function hostDirectory(paths, host) {
+  return path.join(paths.hostsDir, hostDirectoryName(host));
+}
+function writeFileAtomicSync(file, content) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    writeFileSync(temporary, content);
+    renameSync(temporary, file);
+  } catch (error2) {
+    rmSync(temporary, { force: true });
+    throw error2;
+  }
+}
+function writeJsonAtomicSync(file, value) {
+  writeFileAtomicSync(file, `${JSON.stringify(value, void 0, 2)}
+`);
+}
+function readJsonSync(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return error2.code === "EPERM";
+  }
+}
+function parseRecord(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { pid, host, startedAt } = value;
+  if (typeof pid !== "number" || typeof host !== "string") return void 0;
+  return {
+    pid,
+    host,
+    startedAt: typeof startedAt === "string" ? startedAt : ""
+  };
+}
+function readPidState(paths) {
+  const record = parseRecord(readJsonSync(paths.pidFile));
+  if (!record) return { state: "absent" };
+  return isProcessAlive(record.pid) ? { state: "running", record } : { state: "stale", record };
+}
+function writePidFile(paths, record) {
+  writeJsonAtomicSync(paths.pidFile, record);
+}
+function removePidFile(paths, pid) {
+  const record = parseRecord(readJsonSync(paths.pidFile));
+  if (record?.pid === pid) rmSync(paths.pidFile, { force: true });
+}
+function restart(env = process.env) {
+  const paths = statePaths(aibexHome(env));
+  const running = readPidState(paths);
+  if (running.state !== "running") {
+    error("aibexd is not running. Run `aibexd start` to start it.");
+    return 1;
+  }
+  const { pid, host } = running.record;
+  try {
+    process.kill(pid, "SIGHUP");
+  } catch {
+    error("aibexd is not running. Run `aibexd start` to start it.");
+    return 1;
+  }
+  out(
+    `restarting the supervisor of aibexd (pid ${pid}) against ${host} from the installed code`
+  );
+  return 0;
+}
+function log(source, message) {
+  process.stdout.write(`[${source}] ${message}
+`);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes >= 60) {
+    const hours = Math.floor(minutes / 60);
+    const restMinutes = minutes % 60;
+    return restMinutes === 0 ? `${hours}h` : `${hours}h${restMinutes}m`;
+  }
+  const rest = seconds % 60;
+  return rest === 0 ? `${minutes}m` : `${minutes}m${rest}s`;
+}
+function supervisorPath() {
+  return path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "supervisor.js"
+  );
+}
+function describeExit(code, signal) {
+  return signal ? `killed by ${signal}` : `exited with code ${code ?? 0}`;
+}
+function runOuterLoop(options) {
+  const { env, timings } = options;
+  let child;
+  let startedAt = 0;
+  let delay = timings.backoffInitialMs;
+  let restartTimer;
+  let killTimer;
+  let stopping = false;
+  let restartNow = false;
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(restartTimer);
+      clearTimeout(killTimer);
+      process.off("SIGHUP", onHangup);
+      process.off("SIGINT", onStop);
+      process.off("SIGTERM", onStop);
+      log("aibexd", "stopped");
+      options.onExit();
+      resolve(0);
+    };
+    const scheduleRestart = () => {
+      const wait = delay;
+      delay = Math.min(delay * 2, timings.backoffMaxMs);
+      restartTimer = setTimeout(start2, wait);
+    };
+    const start2 = () => {
+      restartTimer = void 0;
+      const entry = supervisorPath();
+      if (!existsSync(entry)) {
+        const wait = delay;
+        log(
+          "aibexd",
+          `no supervisor at ${entry}; aibexd was moved or uninstalled, run \`aibexd start\` again (retrying in ${formatDuration(wait)})`
+        );
+        scheduleRestart();
+        return;
+      }
+      startedAt = Date.now();
+      const started = fork(entry, [], { stdio: "inherit", env });
+      child = started;
+      started.on("error", (error2) => {
+        log("aibexd", `supervisor error: ${error2.message}`);
+      });
+      started.on("exit", (code, signal) => {
+        if (child !== started) return;
+        child = void 0;
+        clearTimeout(killTimer);
+        if (stopping) {
+          finish();
+          return;
+        }
+        if (restartNow) {
+          restartNow = false;
+          delay = timings.backoffInitialMs;
+          start2();
+          return;
+        }
+        if (Date.now() - startedAt >= timings.backoffResetMs) {
+          delay = timings.backoffInitialMs;
+        }
+        log(
+          "aibexd",
+          `supervisor ${describeExit(code, signal)}; restarting in ${formatDuration(delay)}`
+        );
+        scheduleRestart();
+      });
+    };
+    const onHangup = () => {
+      if (stopping) return;
+      log("aibexd", "restarting the supervisor");
+      if (child) {
+        restartNow = true;
+        child.kill("SIGTERM");
+        return;
+      }
+      clearTimeout(restartTimer);
+      delay = timings.backoffInitialMs;
+      start2();
+    };
+    const onStop = () => {
+      if (stopping) {
+        child?.kill("SIGKILL");
+        return;
+      }
+      stopping = true;
+      clearTimeout(restartTimer);
+      if (!child) {
+        finish();
+        return;
+      }
+      log("aibexd", "stopping");
+      child.kill("SIGTERM");
+      const stopped = child;
+      killTimer = setTimeout(() => {
+        stopped.kill("SIGKILL");
+      }, timings.supervisorStopMs);
+    };
+    process.on("SIGHUP", onHangup);
+    process.on("SIGINT", onStop);
+    process.on("SIGTERM", onStop);
+    start2();
+  });
+}
+const DEFAULT_HOST = "https://aibex-herd.aibex.workers.dev";
+const HOST_FORMS = "an https:// URL, or an http:// URL on localhost or 127.0.0.1";
+const LOCAL_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+function parseHost(input) {
+  const invalid = (why) => ({
+    ok: false,
+    error: `Invalid host "${input}": ${why}. Use ${HOST_FORMS}.`
+  });
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    return invalid("not a URL");
+  }
+  if (url.protocol === "http:") {
+    if (!LOCAL_HOSTNAMES.has(url.hostname)) {
+      return invalid("http is only accepted on localhost or 127.0.0.1");
+    }
+  } else if (url.protocol !== "https:") {
+    return invalid(`${url.protocol} is not http or https`);
+  }
+  if (url.username || url.password) return invalid("it has credentials");
+  if (url.pathname !== "/" || url.search || url.hash) {
+    return invalid("it has a path, query or fragment");
+  }
+  return { ok: true, host: url.origin };
+}
+function chooseHost(flag, remembered) {
+  if (flag !== void 0) return parseHost(flag);
+  if (remembered !== void 0) return parseHost(remembered);
+  return { ok: true, host: DEFAULT_HOST };
+}
+const PACKAGE_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+function readInstalledVersion(root = PACKAGE_ROOT) {
+  const manifest = JSON.parse(
+    readFileSync(path.join(root, "package.json"), "utf8")
+  );
+  if (typeof manifest.version !== "string") {
+    throw new TypeError(`${root}/package.json has no version`);
+  }
+  return manifest.version;
+}
+function readConfig(paths) {
+  const value = readJsonSync(paths.configFile);
+  if (typeof value !== "object" || value === null) return {};
+  const host = value.host;
+  return typeof host === "string" ? { host } : {};
+}
+function writeConfig(paths, config) {
+  writeJsonAtomicSync(paths.configFile, config);
+}
+const DEFAULT_TIMINGS = {
+  backoffInitialMs: 1e3,
+  backoffMaxMs: 5 * 6e4,
+  backoffResetMs: 10 * 6e4,
+  hungMs: 9e4,
+  linkStopMs: 1e4,
+  supervisorStopMs: 12e3,
+  versionCheckMs: 5 * 6e4,
+  stopWaitMs: 15e3,
+  updateCheckMs: 60 * 6e4,
+  attemptInitialMs: 15 * 6e4,
+  attemptMaxMs: 6 * 60 * 6e4,
+  probationMs: 2 * 6e4,
+  readyTimeoutMs: 3e4,
+  selfTestMs: 3e4,
+  npmViewMs: 6e4,
+  npmInstallMs: 10 * 6e4,
+  aibexdCheckMs: 24 * 60 * 6e4,
+  updateWaitMs: 15 * 6e4
+};
+function readTimings(env = process.env) {
+  const timings = { ...DEFAULT_TIMINGS };
+  const raw = env.AIBEX_TIMINGS;
+  if (!raw) return timings;
+  let overrides;
+  try {
+    overrides = JSON.parse(raw);
+  } catch {
+    return timings;
+  }
+  if (typeof overrides !== "object" || overrides === null) return timings;
+  for (const key of Object.keys(timings)) {
+    const value = overrides[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      timings[key] = value;
+    }
+  }
+  return timings;
+}
+async function start(hostFlag, env = process.env) {
+  const paths = statePaths(aibexHome(env));
+  let requested;
+  if (hostFlag !== void 0) {
+    const parsed = parseHost(hostFlag);
+    if (!parsed.ok) {
+      error(parsed.error);
+      return 1;
+    }
+    requested = parsed.host;
+  }
+  const running = readPidState(paths);
+  if (running.state === "running") {
+    const { pid, host: host2 } = running.record;
+    if (requested !== void 0 && requested !== host2) {
+      error(
+        `aibexd is already running against ${host2} (pid ${pid}). Run \`aibexd stop\` first, then \`aibexd start --host ${requested}\`.`
+      );
+      return 1;
+    }
+    out(`aibexd is already running against ${host2} (pid ${pid})`);
+    return 0;
+  }
+  const chosen = chooseHost(requested, readConfig(paths).host);
+  if (!chosen.ok) {
+    error(`${chosen.error} Pass --host to replace the remembered host.`);
+    return 1;
+  }
+  const host = chosen.host;
+  writeConfig(paths, { host });
+  const hostDirectoryPath = hostDirectory(paths, host);
+  mkdirSync(hostDirectoryPath, { recursive: true });
+  writePidFile(paths, {
+    pid: process.pid,
+    host,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const removeOwnPidFile = () => removePidFile(paths, process.pid);
+  process.on("exit", removeOwnPidFile);
+  out(
+    `aibexd ${readInstalledVersion()} starting against ${host} (pid ${process.pid}, state in ${paths.home})`
+  );
+  const supervisorEnvironment = {
+    ...env,
+    AIBEX_HOME: paths.home,
+    AIBEX_HOST: host,
+    AIBEX_HOST_DIR: hostDirectoryPath
+  };
+  if (env.AIBEX_LINK_PATH) {
+    supervisorEnvironment.AIBEX_LINK_PATH = path.resolve(env.AIBEX_LINK_PATH);
+    out(`using the local link at ${supervisorEnvironment.AIBEX_LINK_PATH}`);
+  }
+  return runOuterLoop({
+    env: supervisorEnvironment,
+    timings: readTimings(env),
+    onExit: removeOwnPidFile
+  });
+}
+function readSupervisorState(paths) {
+  const value = readJsonSync(paths.stateFile);
+  if (typeof value !== "object" || value === null) return void 0;
+  const state = value;
+  if (typeof state.supervisor?.pid !== "number" || typeof state.link !== "object" || !Array.isArray(state.warnings)) {
+    return void 0;
+  }
+  return state;
+}
+function collectStatus(env = process.env) {
+  const paths = statePaths(aibexHome(env));
+  const installed = readInstalledVersion();
+  const pidState = readPidState(paths);
+  if (pidState.state !== "running") {
+    return {
+      running: false,
+      pid: null,
+      host: readConfig(paths).host ?? null,
+      home: paths.home,
+      aibexd: { installed, running: null },
+      supervisor: { running: false, pid: null, version: null },
+      link: {
+        running: false,
+        pid: null,
+        version: null,
+        source: null,
+        path: null,
+        readyAt: null,
+        lastAliveAt: null,
+        reason: "aibexd is not running"
+      },
+      versions: null,
+      warnings: []
+    };
+  }
+  const state = readSupervisorState(paths);
+  const supervisorRunning = state !== void 0 && isProcessAlive(state.supervisor.pid);
+  const link = state?.link;
+  const linkRunning = supervisorRunning && link?.status === "running" && link.pid !== null && isProcessAlive(link.pid);
+  let reason = null;
+  if (!supervisorRunning) {
+    reason = "the supervisor is not running";
+  } else if (!linkRunning) {
+    reason = link?.reason ?? "the link is not running";
+  }
+  return {
+    running: true,
+    pid: pidState.record.pid,
+    host: pidState.record.host,
+    home: paths.home,
+    aibexd: {
+      installed,
+      running: supervisorRunning ? state?.supervisor.version ?? null : null
+    },
+    supervisor: {
+      running: supervisorRunning,
+      pid: supervisorRunning ? state?.supervisor.pid ?? null : null,
+      version: supervisorRunning ? state?.supervisor.version ?? null : null
+    },
+    link: {
+      running: linkRunning,
+      pid: linkRunning ? link?.pid ?? null : null,
+      version: link?.version ?? null,
+      source: link?.source ?? null,
+      path: link?.path ?? null,
+      readyAt: linkRunning ? link?.readyAt ?? null : null,
+      lastAliveAt: linkRunning ? link?.lastAliveAt ?? null : null,
+      reason
+    },
+    versions: supervisorRunning && state?.versions ? {
+      current: state.versions.current,
+      previous: state.versions.previous,
+      bad: state.versions.bad
+    } : null,
+    warnings: supervisorRunning ? state?.warnings ?? [] : []
+  };
+}
+function formatStatus(status2) {
+  if (!status2.running) {
+    return [
+      "aibexd: stopped",
+      `host: ${status2.host ?? "none recorded"} (last used)`,
+      `aibexd version: ${status2.aibexd.installed} installed`,
+      `state: ${status2.home}`
+    ];
+  }
+  const lines = [
+    `aibexd: running (pid ${status2.pid})`,
+    `host: ${status2.host}`,
+    `aibexd version: ${status2.aibexd.installed} installed, ${status2.aibexd.running ?? "none"} running`,
+    status2.supervisor.running ? `supervisor: running (pid ${status2.supervisor.pid})` : "supervisor: not running (aibexd is restarting it)"
+  ];
+  const { link } = status2;
+  let from = "";
+  if (link.source === "local" && link.path) {
+    from = `, local build at ${link.path}`;
+  } else if (link.source === "installed" && link.path) {
+    from = `, installed at ${link.path}`;
+  }
+  lines.push(
+    link.running ? `link: aibex-link ${link.version} running (pid ${link.pid}${from})` : `link: not running: ${link.reason}`,
+    `state: ${status2.home}`
+  );
+  if (status2.versions) {
+    const { current, previous, bad } = status2.versions;
+    const badVersions = Object.keys(bad);
+    lines.push(
+      `link versions: ${current ?? "none"} current${previous ? `, ${previous} previous` : ""}${badVersions.length > 0 ? `, ${badVersions.join(", ")} bad` : ""}`
+    );
+  }
+  if (status2.warnings.length === 0) {
+    lines.push("warnings: none");
+  } else {
+    lines.push("warnings:");
+    for (const warning of status2.warnings) lines.push(`  - ${warning.message}`);
+  }
+  return lines;
+}
+function status(json, env = process.env) {
+  const current = collectStatus(env);
+  if (json) {
+    out(JSON.stringify(current));
+  } else {
+    for (const line of formatStatus(current)) out(line);
+  }
+  return 0;
+}
+const POLL_MS = 100;
+async function stop(env = process.env) {
+  const paths = statePaths(aibexHome(env));
+  const running = readPidState(paths);
+  if (running.state !== "running") {
+    out("aibexd was not running");
+    return 0;
+  }
+  const { pid } = running.record;
+  const linkPid = readSupervisorState(paths)?.link.pid ?? void 0;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    out("aibexd was not running");
+    return 0;
+  }
+  const deadline = Date.now() + readTimings(env).stopWaitMs;
+  const pending = () => [pid, linkPid].find(
+    (candidate) => candidate !== void 0 && isProcessAlive(candidate)
+  );
+  while (pending() !== void 0 && Date.now() < deadline) {
+    await setTimeout$1(POLL_MS);
+  }
+  const still = pending();
+  if (still !== void 0) {
+    error(
+      `aibexd did not stop in time: pid ${still} is still running${still === pid ? "" : " (the link)"}`
+    );
+    return 1;
+  }
+  out(`aibexd stopped (was pid ${pid})`);
+  return 0;
+}
+const MAX_SOCKET_PATH_BYTES = 100;
+function socketAddress(socketFile) {
+  if (Buffer.byteLength(socketFile) <= MAX_SOCKET_PATH_BYTES) return socketFile;
+  process.chdir(path.dirname(socketFile));
+  return path.basename(socketFile);
+}
+function requestSupervisor(socketFile, request, timeoutMs) {
+  return new Promise((resolve) => {
+    let buffer = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      connection.destroy();
+      resolve(result);
+    };
+    let address;
+    try {
+      address = socketAddress(socketFile);
+    } catch {
+      resolve({ ok: false, reason: "not-listening" });
+      return;
+    }
+    const connection = createConnection(address);
+    const timer = setTimeout(
+      () => finish({ ok: false, reason: "timeout" }),
+      timeoutMs
+    );
+    connection.setEncoding("utf8");
+    connection.on("connect", () => {
+      connection.write(`${JSON.stringify(request)}
+`);
+    });
+    connection.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    connection.on("end", () => {
+      try {
+        finish({
+          ok: true,
+          response: JSON.parse(buffer.trim())
+        });
+      } catch {
+        finish({ ok: false, reason: "bad-response" });
+      }
+    });
+    connection.on(
+      "error",
+      () => finish({ ok: false, reason: "not-listening" })
+    );
+  });
+}
+function describeReport(report) {
+  switch (report.kind) {
+    case "switched": {
+      return {
+        ok: true,
+        message: report.from ? `aibex-link updated from ${report.from} to ${report.to}` : `aibex-link ${report.to} installed and running`
+      };
+    }
+    case "up-to-date": {
+      return {
+        ok: true,
+        message: `aibex-link ${report.version} is up to date`
+      };
+    }
+    case "bad": {
+      return {
+        ok: false,
+        message: `aibex-link ${report.version} is the latest, but it will not be run: ${report.reason}`
+      };
+    }
+    case "failed": {
+      return {
+        ok: false,
+        message: `could not update aibex-link${report.version ? ` to ${report.version}` : ""}: ${report.reason}`
+      };
+    }
+    case "rolled-back": {
+      return {
+        ok: false,
+        message: `aibex-link ${report.from} was rolled back to ${report.to}: ${report.reason}`
+      };
+    }
+  }
+}
+async function update(env = process.env) {
+  const paths = statePaths(aibexHome(env));
+  if (readPidState(paths).state !== "running") {
+    error("aibexd is not running. Run `aibexd start` first.");
+    return 1;
+  }
+  const timings = readTimings(env);
+  out("checking npm for a newer aibex-link...");
+  const result = await requestSupervisor(
+    paths.socketFile,
+    { type: "update" },
+    timings.updateWaitMs
+  );
+  if (!result.ok) {
+    switch (result.reason) {
+      case "not-listening": {
+        error(
+          "the aibexd supervisor is not answering (it may be restarting). Try again in a moment, or see `aibexd status`."
+        );
+        break;
+      }
+      case "timeout": {
+        error(
+          `no answer from the aibexd supervisor in ${formatDuration(timings.updateWaitMs)}; the update may still finish. See \`aibexd status\`.`
+        );
+        break;
+      }
+      case "bad-response": {
+        error("the aibexd supervisor gave an answer this aibexd cannot read.");
+        break;
+      }
+    }
+    return 1;
+  }
+  const { response } = result;
+  if (!response.ok) {
+    error(response.error);
+    return 1;
+  }
+  const described = describeReport(response.report);
+  if (described.ok) {
+    out(described.message);
+    return 0;
+  }
+  error(described.message);
+  return 1;
+}
+const USAGE = `Usage: aibexd <command> [options]
+
+Commands:
+  start [--host <url>]   Run aibexd in the foreground (Ctrl-C to stop)
+  stop                   Stop the running aibexd
+  restart                Restart the supervisor and link from the installed code
+  status [--json]        Show whether aibexd and its link are running
+  update                 Check npm for a newer aibex-link now and switch to it
+
+Options:
+  --version              Print the installed aibexd version
+  -h, --help             Show this help`;
+async function main(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        version: { type: "boolean" },
+        help: { type: "boolean", short: "h" },
+        host: { type: "string" },
+        json: { type: "boolean" }
+      }
+    });
+  } catch (error_) {
+    error(error_.message);
+    error(USAGE);
+    return 2;
+  }
+  const { values, positionals } = parsed;
+  if (values.version) {
+    out(readInstalledVersion());
+    return 0;
+  }
+  if (values.help) {
+    out(USAGE);
+    return 0;
+  }
+  const [command, ...rest] = positionals;
+  if (rest.length > 0) {
+    error(`Unexpected arguments: ${rest.join(" ")}`);
+    return 2;
+  }
+  if (values.host !== void 0 && command !== "start") {
+    error("--host is only accepted by `aibexd start`");
+    return 2;
+  }
+  if (values.json && command !== "status") {
+    error("--json is only accepted by `aibexd status`");
+    return 2;
+  }
+  switch (command) {
+    case "start": {
+      return start(values.host);
+    }
+    case "stop": {
+      return stop();
+    }
+    case "restart": {
+      return restart();
+    }
+    case "status": {
+      return status(values.json ?? false);
+    }
+    case "update": {
+      return update();
+    }
+    case void 0: {
+      error(USAGE);
+      return 2;
+    }
+    default: {
+      error(`Unknown command: ${command}`);
+      error(USAGE);
+      return 2;
+    }
+  }
+}
+process.exitCode = await main(process.argv.slice(2));