@terminus-ai/cli 0.0.1

package/bin/dev-ports.mjs

@@ -0,0 +1,567 @@
+import { execFile } from "node:child_process";
+import { createServer } from "node:http";
+import { connect } from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import { CliError, usageError } from "./client.mjs";
+
+const execFileAsync = promisify(execFile);
+const MAX_PORT = 65_535;
+const PORT_SUGGESTION_ATTEMPTS = 100;
+const SENSITIVE_VALUE_FLAGS = new Set(["--token"]);
+const HARNESS_ANSWER_TIMEOUT_MS = 750;
+const LISTENER_CHECK_TIMEOUT_MS = 500;
+const MAX_COMMAND_LINE = 96;
+/** Every dev server listens here and nowhere else. Their pages carry dev
+ * tokens and brokered capabilities, and agent dev executes on this machine:
+ * none of it is for the network. */
+const LOOPBACK_HOST = "127.0.0.1";
+
+/** Where a running harness says what it is — app, folder, members, PID — so a
+ * `terminus dev` that collides with one of its ports can name it. */
+export const DEV_ABOUT_PATH = "/__terminus_dev/about";
+
+/** Parse and validate a consecutive port range before startup mutates state. */
+export function resolveDevPortRange(rawPort, count, defaultPort = 8868) {
+  const basePort = Number(rawPort ?? defaultPort);
+  if (!Number.isSafeInteger(basePort) || basePort < 0 || basePort > MAX_PORT) {
+    throw usageError("--port must be an integer between 0 and 65535");
+  }
+  if (!Number.isSafeInteger(count) || count < 1) {
+    throw new CliError("terminus dev needs at least one local port");
+  }
+  if (basePort !== 0 && basePort + count - 1 > MAX_PORT) {
+    throw usageError(
+      `--port ${basePort} cannot fit ${count} consecutive ${count === 1 ? "port" : "ports"}`,
+    );
+  }
+  return basePort;
+}
+
+/** Listen on loopback, without leaving a startup-only error handler attached
+ * to the server. `localhost` still reaches it: clients that try ::1 first fall
+ * back to 127.0.0.1 when nothing answers there, which `probePort` makes sure
+ * of before startup. */
+export function listenDevServer(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, LOOPBACK_HOST);
+  });
+}
+
+export async function closeDevServer(server) {
+  if (!server.listening) return;
+  server.closeAllConnections?.();
+  await new Promise((resolve) => server.close(() => resolve()));
+}
+
+/** Whether a request was addressed to this machine by name: its Host is
+ * localhost, a *.localhost name, a 127.x address, or [::1], at any port.
+ *
+ * Listening on loopback keeps other machines out; this keeps out web pages.
+ * A page on attacker.example can re-point its own name at 127.0.0.1 (DNS
+ * rebinding), and its browser then treats a dev server as the attacker's own
+ * origin: free to read the page that carries a dev token, and every door the
+ * token opens. Such a request still says `Host: attacker.example`. The port
+ * is not checked, so a proxy that keeps its own Host (the scaffolded Vite
+ * proxy sends localhost:5173) still passes. */
+export function isLoopbackHost(request) {
+  const host = String(request.headers.host ?? "").trim();
+  return isLoopbackName(host.startsWith("[") ? host.slice(0, host.indexOf("]") + 1) : host.replace(/:\d*$/, ""));
+}
+
+/** localhost, a *.localhost name, a 127.x address, or [::1]: the one
+ * definition of this machine that the Host and Origin checks share. */
+function isLoopbackName(name) {
+  const bare = name.toLowerCase().replace(/\.$/, "");
+  return bare === "localhost" || bare.endsWith(".localhost") || bare === "[::1]"
+    || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(bare);
+}
+
+/** Whether a request came from a page on this machine, or from no page at
+ * all. The Host check keeps out rebound names, but not a page anywhere that
+ * fires requests at localhost blind (CSRF): it never reads the answer, and
+ * the write happens anyway. Browsers name the page that made a request:
+ * `Origin` on every cross-origin fetch and every POST, and `Sec-Fetch-Site`
+ * on all of them, including the no-cors GETs (an <img>, a <script>) that
+ * carry no Origin. curl, node, and the SDK outside a browser send neither
+ * and pass. A loopback page at another port (the Vite dev server's) passes. */
+export function isLoopbackOrigin(request) {
+  const origin = request.headers.origin;
+  if (origin === undefined) return request.headers["sec-fetch-site"] !== "cross-site";
+  try {
+    const { protocol, hostname } = new URL(origin);
+    return (protocol === "http:" || protocol === "https:") && isLoopbackName(hostname);
+  } catch {
+    // "null" (a sandboxed frame, a file: page) and anything unparseable.
+    return false;
+  }
+}
+
+/** Whether a request came from a page on the origin it was sent to: its
+ * `Origin` (or else its `Referer`) names the host and port its `Host` does —
+ * the rule the app host holds every mutation to. A form a browser posts
+ * always carries one; a page on another port, even a loopback one, fails. The
+ * Vite dev server's proxy keeps its own `Host`, so a page it serves passes. */
+export function isSameOrigin(request) {
+  const host = String(request.headers.host ?? "").trim().toLowerCase();
+  const source = request.headers.origin ?? request.headers.referer;
+  if (!host || typeof source !== "string") return false;
+  try {
+    const url = new URL(source);
+    return (url.protocol === "http:" || url.protocol === "https:") && url.host.toLowerCase() === host;
+  } catch {
+    // "null" (a sandboxed frame, a no-referrer page) and anything unparseable.
+    return false;
+  }
+}
+
+/** The answer to a runtime request that fails isLoopbackOrigin. */
+export function refuseCrossSite(response) {
+  response.writeHead(403, { "content-type": "application/json" });
+  response.end(JSON.stringify({
+    error: { code: "forbidden", message: "terminus dev refuses requests from pages on other sites" },
+  }));
+}
+
+/** The answer to a request that fails isLoopbackHost. */
+export function refuseForeignHost(request, response) {
+  response.writeHead(403, { "content-type": "application/json" });
+  response.end(JSON.stringify({
+    error: {
+      code: "forbidden",
+      message: "terminus dev only answers requests addressed to localhost: "
+        + `open http://localhost:${request.socket.localPort}/`,
+    },
+  }));
+}
+
+/** Answer DEV_ABOUT_PATH. Only this machine can ask: the server listens on
+ * loopback. */
+export function answerDevAbout(request, response, about) {
+  response.writeHead(200, { "cache-control": "no-store", "content-type": "application/json" });
+  return response.end(JSON.stringify({
+    ...about,
+    pid: process.pid,
+    started_at: new Date(performance.timeOrigin).toISOString(),
+  }));
+}
+
+/** Whether anything accepts connections on this loopback address and port.
+ * A connect that hangs means a listener whose backlog is full. */
+function acceptsOn(host, port) {
+  return new Promise((resolve) => {
+    const socket = connect({ host, port });
+    socket.setTimeout(LISTENER_CHECK_TIMEOUT_MS);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    // Refused, or no IPv6 loopback on this machine at all.
+    socket.once("error", () => resolve(false));
+  });
+}
+
+/** Whether a dev server could own localhost:port. Binding 127.0.0.1 alone
+ * cannot say: on macOS it coexists silently with a listener on the wildcard
+ * or on ::1, and a browser that resolves localhost to ::1 would reach that
+ * one instead. So anything answering on either loopback address holds the
+ * port, and the bind catches the rest (a privileged port, a socket bound but
+ * not yet listening). */
+async function probePort(port) {
+  const answered = await Promise.all([acceptsOn(LOOPBACK_HOST, port), acceptsOn("::1", port)]);
+  if (answered.includes(true)) {
+    return Object.assign(new Error(`port ${port} is in use`), { code: "EADDRINUSE" });
+  }
+  const server = createServer();
+  try {
+    await listenDevServer(server, port);
+    return null;
+  } catch (error) {
+    return error;
+  } finally {
+    await closeDevServer(server);
+  }
+}
+
+async function unavailablePorts(basePort, count) {
+  const results = await Promise.all(
+    Array.from({ length: count }, async (_, index) => {
+      const port = basePort + index;
+      return { port, error: await probePort(port) };
+    }),
+  );
+  return results.filter(({ error }) => error);
+}
+
+async function processListeningOn(port) {
+  if (process.platform === "win32") return null;
+  try {
+    const { stdout } = await execFileAsync(
+      "lsof",
+      ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fpc"],
+      { encoding: "utf8", timeout: 1_500 },
+    );
+    const listeners = [];
+    let current = null;
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("p")) {
+        current = { pid: line.slice(1), command: null };
+        listeners.push(current);
+      } else if (line.startsWith("c") && current) {
+        current.command = line.slice(1);
+      }
+    }
+    return listeners.find(({ pid }) => /^\d+$/.test(pid)) ?? null;
+  } catch {
+    // `lsof` is optional. The error still includes a copyable inspection command.
+    return null;
+  }
+}
+
+/** Ask the port itself: a harness answers DEV_ABOUT_PATH. */
+async function harnessOn(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}${DEV_ABOUT_PATH}`, {
+      signal: AbortSignal.timeout(HARNESS_ANSWER_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      return null;
+    }
+    const about = await response.json();
+    return typeof about?.app === "string" && Number.isSafeInteger(about.pid) ? about : null;
+  } catch {
+    return null;
+  }
+}
+
+/** ps's elapsed time, `[[dd-]hh:]mm:ss`, in seconds. */
+function elapsedSeconds(text) {
+  const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(text);
+  if (!match) return null;
+  const [days, hours, minutes, seconds] = match.slice(1).map((part) => Number(part ?? 0));
+  return ((days * 24 + hours) * 60 + minutes) * 60 + seconds;
+}
+
+/** The listener's command line, folder, and start time, from ps and lsof. */
+async function processDetails(pid) {
+  if (process.platform === "win32") return {};
+  // Under the C locale both tools escape every non-ASCII byte, which garbles
+  // a folder named in any script but Latin.
+  const options = { encoding: "utf8", env: { ...process.env, LC_ALL: "C.UTF-8" }, timeout: 1_500 };
+  const read = (file, args) => execFileAsync(file, args, options).then(({ stdout }) => stdout, () => "");
+  const [ps, cwd] = await Promise.all([
+    read("ps", ["-ww", "-o", "etime=,args=", "-p", pid]),
+    read("lsof", ["-a", "-p", pid, "-d", "cwd", "-Fn"]),
+  ]);
+  const [, elapsed, args] = /^\s*(\S+)\s+(.*\S)/.exec(ps) ?? [];
+  const seconds = elapsed ? elapsedSeconds(elapsed) : null;
+  return {
+    args: args ?? null,
+    directory: /^n(.+)$/m.exec(cwd)?.[1] ?? null,
+    startedAt: seconds === null ? null : Date.now() - seconds * 1_000,
+  };
+}
+
+/** Who holds a port, as far as this machine will say. A harness names its
+ * app; anything else is the listening process, its command line and folder. */
+async function portHolder(port) {
+  const [listener, about] = await Promise.all([processListeningOn(port), harnessOn(port)]);
+  // An answer from a PID other than the listener's came through a proxy, and
+  // the proxy is what holds the port.
+  if (about && (!listener || listener.pid === String(about.pid))) {
+    return {
+      pid: about.pid,
+      app: about.app,
+      kind: ["app", "agent", "service"].includes(about.kind) ? about.kind : null,
+      remote: about.remote === true,
+      member: typeof about.member === "string" ? about.member : null,
+      // The port a --guest harness keeps for a visitor who is not signed in.
+      guest: Number.isSafeInteger(about.guest_port) && about.guest_port === port,
+      ports: [...Object.values(about.ports ?? {}), about.guest_port].filter(Number.isSafeInteger),
+      directory: typeof about.directory === "string" ? about.directory : null,
+      startedAt: Date.parse(about.started_at) || null,
+    };
+  }
+  if (!listener) return null;
+  return {
+    pid: Number(listener.pid),
+    command: listener.command,
+    ...(await processDetails(listener.pid)),
+  };
+}
+
+async function nextAvailableRange(basePort, count) {
+  const firstCandidate = basePort + count;
+  for (let offset = 0; offset < PORT_SUGGESTION_ATTEMPTS; offset += 1) {
+    const candidate = firstCandidate + offset;
+    if (candidate + count - 1 > MAX_PORT) return null;
+    if ((await unavailablePorts(candidate, count)).length === 0) return candidate;
+  }
+  return null;
+}
+
+function rangeLabel(basePort, count) {
+  return count === 1 ? String(basePort) : `${basePort}-${basePort + count - 1}`;
+}
+
+function listLabel(items) {
+  return items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+
+function inspectionCommand(port) {
+  if (process.platform === "win32") return `netstat -ano | findstr :${port}`;
+  return `lsof -nP -iTCP:${port} -sTCP:LISTEN`;
+}
+
+function stopCommand(pids) {
+  if (process.platform === "win32") return `taskkill ${pids.map((pid) => `/PID ${pid}`).join(" ")}`;
+  return `kill ${pids.join(" ")}`;
+}
+
+/** Text from another process — its answer, its command line — is headed for a
+ * terminal: controls and direction overrides go, whitespace folds, and an
+ * overlong line loses its middle, keeping the program and its arguments. */
+function terminalText(value, max = Infinity) {
+  const chars = [];
+  for (const char of String(value ?? "")) {
+    const code = char.codePointAt(0);
+    const hidden = code < 0x20 || (code >= 0x7f && code < 0xa0) || code === 0x200e || code === 0x200f
+      || (code >= 0x202a && code <= 0x202e) || (code >= 0x2066 && code <= 0x2069);
+    chars.push(hidden ? " " : char);
+  }
+  const folded = [...chars.join("").replace(/\s+/g, " ").trim()];
+  if (folded.length <= max) return folded.join("");
+  const head = Math.floor((max - 1) * 0.3);
+  return `${folded.slice(0, head).join("")}…${folded.slice(folded.length - (max - 1 - head)).join("")}`;
+}
+
+/** A folder the way the reader would type it: relative when it is nearby. */
+function folderLabel(directory, { cwd, home }) {
+  const relative = path.relative(cwd, directory);
+  if (!relative) return "this folder";
+  const climbs = relative.split(path.sep).filter((part) => part === "..").length;
+  if (!path.isAbsolute(relative) && climbs <= 2) return relative;
+  return home && directory.startsWith(`${home}${path.sep}`) ? `~${directory.slice(home.length)}` : directory;
+}
+
+/** A process's command line, with its own folder and home written short. A
+ * daemon's folder is the root, and dropping that would eat every "//". */
+function commandLabel({ args, command, directory }, { home }) {
+  let text = args ?? command ?? "";
+  if (args && directory && path.dirname(directory) !== directory) {
+    text = text.replaceAll(`${directory}${path.sep}`, "");
+  }
+  if (args && home) text = text.replaceAll(`${home}${path.sep}`, `~${path.sep}`);
+  return terminalText(text, MAX_COMMAND_LINE) || "another process";
+}
+
+function uptimeLabel(milliseconds) {
+  const minutes = Math.floor(milliseconds / 60_000);
+  if (minutes < 1) return "under a minute";
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m`;
+  const days = Math.floor(hours / 24);
+  return `${days} ${days === 1 ? "day" : "days"}`;
+}
+
+function asMember(holder) {
+  if (holder.member) return `, as @${terminalText(holder.member)}`;
+  return holder.guest ? ", as a guest" : "";
+}
+
+function holderTitle(holder, context) {
+  if (!holder.app) return commandLabel(holder, context);
+  const mode = holder.remote ? " --remote" : "";
+  return `terminus dev${mode} for ${terminalText(holder.app, MAX_COMMAND_LINE)}${asMember(holder)}`;
+}
+
+function holderFacts(holder, blocked, context) {
+  const facts = [];
+  if (holder.directory) facts.push(`in ${terminalText(folderLabel(holder.directory, context))}`);
+  facts.push(`PID ${holder.pid}`);
+  if (holder.startedAt) facts.push(`running for ${uptimeLabel(context.now - holder.startedAt)}`);
+  const others = (holder.ports ?? []).filter((port) => !blocked.includes(port));
+  if (others.length) facts.push(`also on ${listLabel(others)}`);
+  return facts.join(" · ");
+}
+
+function shellQuote(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(text)) return text;
+  return `'${text.replaceAll("'", `'"'"'`)}'`;
+}
+
+/** Rebuild the invocation with one final port flag. Raw credential flags are
+ * deliberately omitted so an error never copies a secret into terminal logs. */
+export function devCommandWithPort(args, port) {
+  const kept = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = String(args[index]);
+    const [flag] = argument.split("=", 1);
+    if (flag === "--port" || SENSITIVE_VALUE_FLAGS.has(flag)) {
+      if (!argument.includes("=")) index += 1;
+      continue;
+    }
+    kept.push(argument);
+  }
+  return ["terminus", "dev", ...kept, "--port", String(port)].map(shellQuote).join(" ");
+}
+
+/** The collision report, from what each blocked port said about its holder:
+ * which app (or program) has it, from which folder, since when, and how to
+ * get the port back — stop that holder, or re-run on free ports. Only an app
+ * has the scaffolded Vite proxy to re-point (`viteProxy`), and only an app
+ * run with --guest has the guest's port, the last one (`guest`). */
+export function devPortUnavailableMessage({
+  basePort,
+  commandArgs = [],
+  count,
+  directory = null,
+  failures,
+  guest = false,
+  members = [],
+  suggestion = null,
+  viteProxy = false,
+  now = Date.now(),
+  cwd = process.cwd(),
+  home = os.homedir(),
+}) {
+  const context = { cwd, home, now };
+  const blocked = failures.map(({ port }) => port);
+  const busy = failures.every(({ error }) => error?.code === "EADDRINUSE");
+  const state = `${blocked.length === 1 ? "is" : "are"} ${busy ? "already in use" : "unavailable"}`;
+  const who = guest
+    ? `${members.length} ${members.length === 1 ? "member" : "members"} and a guest`
+    : `${count} members`;
+  const lines = [count === 1
+    ? `Cannot start terminus dev: port ${listLabel(blocked)} ${state}.`
+    : `Cannot start terminus dev: its ${who} need ports ${rangeLabel(basePort, count)},`
+      + ` and ${listLabel(blocked)} ${state}.`];
+  const holders = [];
+  const unknown = [];
+  for (const { port, error, holder } of failures) {
+    const member = count > 1 ? members[port - basePort] : null;
+    const seat = member ? `@${member}` : guest && port - basePort === members.length ? "the guest" : null;
+    const label = `  ${port}${seat ? ` (for ${seat})` : ""}:`;
+    if (error?.code !== "EADDRINUSE") {
+      lines.push(`${label} could not be bound${error?.code ? ` (${error.code})` : ""}`);
+    } else if (!holder) {
+      unknown.push(port);
+      lines.push(`${label} in use by another process`);
+    } else if (holders.some(({ pid }) => pid === holder.pid)) {
+      lines.push(`${label} the same ${holder.app ? "terminus dev" : "process"}${asMember(holder)}`);
+    } else {
+      holders.push({ ...holder, port });
+      lines.push(`${label} ${holderTitle(holder, context)}`, `    ${holderFacts(holder, blocked, context)}`);
+    }
+  }
+  const steps = [];
+  const itself = directory
+    ? holders.find((holder) => holder.app && holder.directory === path.resolve(directory))
+    : null;
+  if (itself) {
+    const address = `http://localhost:${itself.port}/`;
+    steps.push(`terminus dev is already running for this ${itself.kind ?? "folder"} at ${address}.`);
+  }
+  if (holders.length) {
+    const one = holders.length === 1;
+    steps.push(
+      holders.every(({ app }) => app)
+        ? `Stop ${one ? "it" : "them"} with Ctrl-C in ${one ? "its terminal" : "their terminals"}, or run:`
+        : `Stop ${one ? "it" : "them"} if you don't need ${one ? "it" : "them"}:`,
+      `  ${stopCommand(holders.map(({ pid }) => pid))}`,
+    );
+  }
+  if (steps.length) lines.push("", ...steps);
+  if (unknown.length) lines.push("", "Inspect the listener:", `  ${inspectionCommand(unknown[0])}`);
+  // No second copy of an app that is already running: each harness holds the
+  // folder's spaces in memory and saves them whole, so two would overwrite
+  // each other's.
+  if (suggestion !== null && !itself) {
+    lines.push(
+      "",
+      count === 1 ? "Or re-run on a free port:" : `Or re-run on free ports ${rangeLabel(suggestion, count)}:`,
+      `  ${devCommandWithPort(commandArgs, suggestion)}`,
+    );
+    if (viteProxy) {
+      lines.push(`If you use the scaffolded Vite proxy, point its target at http://localhost:${suggestion}.`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/** Turn one or more bind failures into one actionable CLI error. */
+export async function devPortUnavailableError({
+  basePort,
+  commandArgs,
+  count,
+  directory,
+  guest = false,
+  members = [],
+  failures,
+  viteProxy,
+}) {
+  const [described, suggestion] = await Promise.all([
+    Promise.all(failures.map(async (failure) => ({
+      ...failure,
+      holder: failure.error?.code === "EADDRINUSE" ? await portHolder(failure.port) : null,
+    }))),
+    nextAvailableRange(basePort, count),
+  ]);
+  return new CliError(devPortUnavailableMessage({
+    basePort,
+    commandArgs,
+    count,
+    directory,
+    failures: described,
+    guest,
+    members,
+    suggestion,
+    viteProxy,
+  }));
+}
+
+/** Check every requested port before startup does anything costly — clearing
+ * fixtures (`--fresh`), importing a draft, starting an engine. */
+export async function assertDevPortRangeAvailable({
+  basePort,
+  commandArgs,
+  count,
+  directory,
+  guest = false,
+  members = [],
+  viteProxy,
+}) {
+  if (basePort === 0) return;
+  const failures = await unavailablePorts(basePort, count);
+  if (failures.length) {
+    throw await devPortUnavailableError({
+      basePort,
+      commandArgs,
+      count,
+      directory,
+      guest,
+      members,
+      failures,
+      viteProxy,
+    });
+  }
+}

package/bin/dev-server-binding.mjs

@@ -0,0 +1,35 @@
+/**
+ * `agentos-terminus` under `terminus dev`, where curl cannot carry it: the
+ * command an app's server op runs to make a syscall. It hands the command
+ * line to the dev runtime's binding host — which runs outside the op's
+ * sandbox, as the platform's does — and prints the answer the way the
+ * platform's binding command does: the envelope on stdout, or the framed
+ * refusal on stderr with exit status 1. A binding host it cannot reach is
+ * refused the way the platform refuses an unreachable broker.
+ *
+ *   agentos-terminus <binding> --flag value ...
+ */
+
+import { readFileSync } from "node:fs";
+
+const [ticketPath, ...args] = process.argv.slice(2);
+
+try {
+  const { url, token } = JSON.parse(readFileSync(ticketPath, "utf8"));
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}`, "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(args.map((arg) => ["a", arg])).toString(),
+  });
+  const text = await response.text();
+  if (response.ok) {
+    process.stdout.write(text);
+  } else {
+    process.stderr.write(`${text}\n`);
+    process.exitCode = 1;
+  }
+} catch {
+  const action = String(args[0] ?? "").replaceAll("-", "_");
+  process.stderr.write(`${action} failed [service_unavailable 503]: the platform could not be reached\n`);
+  process.exitCode = 1;
+}