@ultra-network/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ultra Network
+
+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

@@ -0,0 +1,77 @@
+# @ultra-network/cli
+
+A spec-driven command-line client for the [Ultra Network](https://ultranetwork.co) Public API v1.
+
+Every operation in `https://ultranetwork.co/api/v1/openapi.json` becomes an `ultra <command>` subcommand. New endpoints become new subcommands automatically — no CLI code change needed.
+
+## Install
+
+```sh
+npm install -g @ultra-network/cli
+```
+
+Or run without installing:
+
+```sh
+npx @ultra-network/cli list_trips --limit=5
+```
+
+## Quick start
+
+```sh
+export ULTRA_API_KEY=ulk_…
+ultra --help                            # list commands grouped by resource
+ultra list_trips --limit=10             # GET /api/v1/trips?limit=10
+ultra get_trip --id=<uuid>              # GET /api/v1/trips/{id}
+ultra create_trip --body='{"title":"Demo","client_id":"…"}'
+ultra create_trip --body=@payload.json  # read body from file
+cat payload.json | ultra create_trip --body=-   # read body from stdin
+ultra list_bookings --trip_id=<uuid> --status   # HTTP status on stderr
+```
+
+Get an API key at [ultranetwork.co/contact](https://ultranetwork.co/contact).
+
+## Environment
+
+| Var | Default | Purpose |
+|---|---|---|
+| `ULTRA_API_KEY` | (required) | Bearer key for `/api/v1` |
+| `ULTRA_API_SPEC` | `https://ultranetwork.co/api/v1/openapi.json` | OpenAPI source |
+| `ULTRA_API_BASE_URL` | (from `spec.servers[0].url`) | Override server base URL |
+| `ULTRA_API_TAGS` | (all) | CSV filter — only expose operations matching these tags |
+
+## Global flags
+
+| Flag | Purpose |
+|---|---|
+| `--spec=<url\|path>` | Override the spec source for one invocation |
+| `--base-url=<url>` | Override the base URL for one invocation |
+| `--status` | Print `HTTP <code>` + `request_id` to stderr |
+| `--raw` | Print response body unchanged (no JSON pretty-print) |
+| `--quiet` | Suppress progress lines on stderr |
+| `--help, -h` | Top-level help, or per-command help when a command is named |
+| `--version, -V` | Print CLI + spec version |
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| 0 | 2xx response |
+| 1 | 4xx response |
+| 2 | 5xx response or network failure |
+| 3 | Usage / parse error |
+| 4 | Spec load failure |
+
+## Architecture
+
+Spec-driven dumb-pipe. At boot the CLI fetches the OpenAPI document, walks the paths, and renders one subcommand per operation. The HTTP layer is shared with the [`@ultra-network/mcp`](https://www.npmjs.com/package/@ultra-network/mcp) server so both surfaces stay in lockstep with the live API.
+
+## Docs
+
+- [Developer docs](https://github.com/timebinder/ultra-developers) — auth, API reference, MCP, errors, pagination
+- [CLI cookbook](https://github.com/timebinder/ultra-developers/blob/main/examples/cli-cookbook.md) — practical recipes
+- [Live API reference](https://ultranetwork.co/api/v1/docs) — interactive Scalar UI
+
+## Licence
+
+MIT

package/dist/cli.cjs

@@ -0,0 +1,541 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+
+// ../ultra-api-client/src/loadSpec.ts
+var import_promises = require("fs/promises");
+async function loadSpec(source) {
+  if (/^https?:\/\//.test(source)) {
+    const res = await fetch(source);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch OpenAPI spec from ${source}: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  const text = await (0, import_promises.readFile)(source, "utf8");
+  return JSON.parse(text);
+}
+
+// ../ultra-api-client/src/toolGenerator.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+function deriveToolName(method, path) {
+  const slug = path.replace(/^\/+/, "").split("/").map((seg) => {
+    const param = /^\{(.+)\}$/.exec(seg);
+    return param ? `by_${param[1]}` : seg;
+  }).join("_");
+  return `${method}_${slug}`.replace(/[^a-z0-9_]/gi, "_").toLowerCase();
+}
+function extractOperations(doc, opts = {}) {
+  const out = [];
+  const tagFilter = (opts.tagFilter ?? []).map((t) => t.toLowerCase());
+  for (const [pathTemplate, pathItem] of Object.entries(doc.paths ?? {})) {
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op) continue;
+      const opTags = (op.tags ?? []).map((t) => t.toLowerCase());
+      if (tagFilter.length && !opTags.some((t) => tagFilter.includes(t))) continue;
+      const params = op.parameters ?? [];
+      const pathParams = params.filter((p) => p.in === "path").map((p) => p.name);
+      const queryParams = params.filter((p) => p.in === "query").map((p) => p.name);
+      const properties = {};
+      const required = [];
+      for (const p of params) {
+        if (p.in !== "path" && p.in !== "query") continue;
+        const schema = p.schema ?? { type: "string" };
+        properties[p.name] = p.description ? { ...schema, description: p.description } : schema;
+        if (p.required) required.push(p.name);
+      }
+      let hasBody = false;
+      let bodyContentType;
+      if (op.requestBody?.content) {
+        const ct = Object.keys(op.requestBody.content)[0];
+        if (ct) {
+          bodyContentType = ct;
+          const bodySchema = op.requestBody.content[ct].schema;
+          if (bodySchema) {
+            properties.body = bodySchema;
+            hasBody = true;
+            if (op.requestBody.required) required.push("body");
+          }
+        }
+      }
+      const inputSchema = {
+        type: "object",
+        properties,
+        ...required.length ? { required } : {}
+      };
+      out.push({
+        name: op.operationId ? toSnake(op.operationId) : deriveToolName(method, pathTemplate),
+        description: op.summary || op.description || `${method.toUpperCase()} ${pathTemplate}`,
+        method,
+        pathTemplate,
+        inputSchema,
+        pathParams,
+        queryParams,
+        hasBody,
+        bodyContentType
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((o) => {
+    if (seen.has(o.name)) return false;
+    seen.add(o.name);
+    return true;
+  });
+}
+function toSnake(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_]/gi, "_").toLowerCase();
+}
+
+// ../ultra-api-client/src/httpExecutor.ts
+async function executeOperation(op, args, opts, fetchImpl = fetch) {
+  let path = op.pathTemplate;
+  for (const name of op.pathParams) {
+    const v = args[name];
+    if (v === void 0 || v === null) {
+      throw new Error(`Missing required path parameter: ${name}`);
+    }
+    path = path.replace(`{${name}}`, encodeURIComponent(String(v)));
+  }
+  const url = new URL(opts.baseUrl.replace(/\/$/, "") + path);
+  for (const name of op.queryParams) {
+    const v = args[name];
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      v.forEach((item) => url.searchParams.append(name, String(item)));
+    } else {
+      url.searchParams.set(name, String(v));
+    }
+  }
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": opts.userAgent || "ultra-api-client/1.0"
+  };
+  if (opts.apiKey) {
+    if (!/^ulk_[A-Za-z0-9_-]+$/.test(opts.apiKey)) {
+      throw new Error(
+        "Invalid API key format (expected `ulk_\u2026`). Check that ULTRA_API_KEY contains exactly one key value \u2014 multi-line input or a grep with multiple matches will fail here."
+      );
+    }
+    headers.Authorization = `Bearer ${opts.apiKey}`;
+  }
+  let body;
+  if (op.hasBody && args.body !== void 0) {
+    headers["Content-Type"] = op.bodyContentType || "application/json";
+    body = typeof args.body === "string" ? args.body : JSON.stringify(args.body);
+  }
+  const res = await fetchImpl(url.toString(), {
+    method: op.method.toUpperCase(),
+    headers,
+    body
+  });
+  const contentType = res.headers.get("content-type") || "";
+  const parsed = contentType.includes("application/json") ? await res.json().catch(() => null) : await res.text();
+  return {
+    status: res.status,
+    body: parsed,
+    request_id: res.headers.get("x-request-id") ?? void 0
+  };
+}
+
+// src/parseArgs.ts
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["spec", "base-url", "status", "raw", "quiet"]);
+function parseArgs(argv) {
+  const flags = {};
+  const global = {};
+  let command;
+  let bodySource;
+  let wantsHelp = false;
+  let wantsVersion = false;
+  const tokens = [...argv];
+  const remaining = [];
+  while (tokens.length) {
+    const t = tokens.shift();
+    if (t === "--help" || t === "-h") {
+      wantsHelp = true;
+      continue;
+    }
+    if (t === "--version" || t === "-V") {
+      wantsVersion = true;
+      continue;
+    }
+    const m = /^--([^=]+)(?:=(.*))?$/.exec(t);
+    if (m && GLOBAL_FLAGS.has(m[1])) {
+      const key = m[1];
+      const value = m[2] ?? (tokens[0] && !tokens[0].startsWith("--") ? tokens.shift() : "true");
+      if (key === "spec") global.spec = value;
+      else if (key === "base-url") global.baseUrl = value;
+      else if (key === "status") global.status = value === "true" || value === "";
+      else if (key === "raw") global.raw = value === "true" || value === "";
+      else if (key === "quiet") global.quiet = value === "true" || value === "";
+      continue;
+    }
+    if (!command && !t.startsWith("-")) {
+      command = t;
+      continue;
+    }
+    remaining.push(t);
+  }
+  if (wantsVersion) return { kind: "version", flags, global };
+  if (!command) return { kind: "help", flags, global };
+  if (wantsHelp) return { kind: "command-help", command, flags, global };
+  while (remaining.length) {
+    const t = remaining.shift();
+    const m = /^--([^=]+)(?:=(.*))?$/.exec(t);
+    if (!m) {
+      throw new Error(`Unexpected positional argument: ${t}`);
+    }
+    const key = m[1];
+    let value = m[2];
+    if (value === void 0) {
+      if (remaining[0] !== void 0 && !remaining[0].startsWith("--")) {
+        value = remaining.shift();
+      }
+    }
+    if (key === "body") {
+      if (value === void 0) throw new Error("--body requires a value");
+      if (value === "-") bodySource = { kind: "stdin" };
+      else if (value.startsWith("@")) bodySource = { kind: "file", path: value.slice(1) };
+      else bodySource = { kind: "inline", text: value };
+      continue;
+    }
+    if (value === void 0) {
+      flags[key] = true;
+      continue;
+    }
+    const existing = flags[key];
+    if (existing === void 0) {
+      flags[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else if (typeof existing === "string") {
+      flags[key] = [existing, value];
+    } else {
+      flags[key] = value;
+    }
+  }
+  return { kind: "command", command, flags, bodySource, global };
+}
+
+// src/help.ts
+var HEADER = `ultra \u2014 Ultra Network public API CLI
+
+A spec-driven wrapper over /api/v1/*. Every endpoint in the OpenAPI document
+becomes a subcommand. Use \`ultra <command> --help\` for per-command flags.
+
+ENVIRONMENT
+  ULTRA_API_KEY        Bearer key for /api/v1 (required for non-discovery)
+  ULTRA_API_SPEC       OpenAPI source (default: https://ultranetwork.co/api/v1/openapi.json)
+  ULTRA_API_BASE_URL   Override server base URL
+  ULTRA_API_TAGS       CSV tag filter for which operations are exposed
+
+GLOBAL FLAGS
+  --spec=<url|path>    Override the spec source for this invocation
+  --base-url=<url>     Override the base URL for this invocation
+  --status             Print HTTP status + request_id to stderr
+  --raw                Print response body unchanged (no JSON pretty-print)
+  --quiet              Suppress progress lines on stderr
+  --help, -h           Show this help (or per-command help)
+  --version, -V        Print CLI + spec version
+`;
+function renderTopLevelHelp(operations) {
+  const out = [HEADER, "COMMANDS"];
+  if (operations.length === 0) {
+    out.push("  (no operations available \u2014 check ULTRA_API_SPEC)");
+    return out.join("\n");
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const group = op.pathTemplate.replace(/^\/+/, "").split("/")[0] || "misc";
+    if (!groups.has(group)) groups.set(group, []);
+    groups.get(group).push(op);
+  }
+  const nameWidth = Math.min(40, Math.max(...operations.map((o) => o.name.length)));
+  for (const [group, ops] of [...groups.entries()].sort()) {
+    out.push("");
+    out.push(`  ${group}/`);
+    for (const op of ops.sort((a, b) => a.name.localeCompare(b.name))) {
+      const padded = op.name.padEnd(nameWidth);
+      out.push(`    ${padded}  ${op.description}`);
+    }
+  }
+  out.push("");
+  out.push("Run `ultra <command> --help` for input details.");
+  return out.join("\n");
+}
+function renderCommandHelp(op) {
+  const out = [];
+  out.push(`ultra ${op.name}`);
+  out.push("");
+  out.push(`  ${op.description}`);
+  out.push(`  ${op.method.toUpperCase()} ${op.pathTemplate}`);
+  out.push("");
+  const schema = op.inputSchema;
+  const required = new Set(schema.required ?? []);
+  const props = schema.properties ?? {};
+  if (op.pathParams.length) {
+    out.push("PATH PARAMETERS (required)");
+    for (const name of op.pathParams) {
+      out.push(formatParam(name, props[name], required.has(name)));
+    }
+    out.push("");
+  }
+  if (op.queryParams.length) {
+    out.push("QUERY PARAMETERS");
+    for (const name of op.queryParams) {
+      out.push(formatParam(name, props[name], required.has(name)));
+    }
+    out.push("");
+  }
+  if (op.hasBody) {
+    out.push("REQUEST BODY");
+    out.push(`  --body=<json> | --body=@path/to/file.json | --body=-  (stdin)`);
+    out.push(`  Content-Type: ${op.bodyContentType || "application/json"}`);
+    if (required.has("body")) out.push("  (required)");
+    out.push("");
+  }
+  out.push("EXAMPLE");
+  out.push(formatExample(op));
+  return out.join("\n");
+}
+function formatParam(name, schema, isRequired) {
+  const tag = isRequired ? " (required)" : "";
+  const type = schema?.type ? ` <${schema.type}>` : "";
+  const desc = schema?.description ? `  \u2014 ${schema.description}` : "";
+  const enumVals = schema?.enum?.length ? `  [${schema.enum.join("|")}]` : "";
+  return `  --${name}${type}${tag}${enumVals}${desc}`;
+}
+function formatExample(op) {
+  const parts = ["  ultra", op.name];
+  for (const p of op.pathParams) parts.push(`--${p}=<${p}>`);
+  for (const q of op.queryParams.slice(0, 2)) parts.push(`--${q}=<value>`);
+  if (op.hasBody) parts.push(`--body='{"\u2026":"\u2026"}'`);
+  return parts.join(" ");
+}
+function renderVersion(cliVersion, specVersion) {
+  return `ultra ${cliVersion}
+spec  ${specVersion ?? "(unknown)"}`;
+}
+
+// src/coerce.ts
+function coerceArgs(rawFlags, inputSchema) {
+  const props = inputSchema.properties ?? {};
+  const out = {};
+  for (const [k, v] of Object.entries(rawFlags)) {
+    const schema = props[k];
+    out[k] = coerceOne(v, schema);
+  }
+  return out;
+}
+function coerceOne(v, schema) {
+  if (typeof v === "boolean") return v;
+  if (Array.isArray(v)) return v.map((x) => coerceScalar(x, schema?.items ?? schema));
+  return coerceScalar(v, schema);
+}
+function coerceScalar(s, schema) {
+  const t = schema?.type;
+  if (t === "integer") {
+    const n = Number.parseInt(s, 10);
+    if (Number.isNaN(n)) throw new Error(`Expected integer, got: ${s}`);
+    return n;
+  }
+  if (t === "number") {
+    const n = Number(s);
+    if (Number.isNaN(n)) throw new Error(`Expected number, got: ${s}`);
+    return n;
+  }
+  if (t === "boolean") {
+    if (s === "true" || s === "1") return true;
+    if (s === "false" || s === "0") return false;
+    throw new Error(`Expected boolean, got: ${s}`);
+  }
+  return s;
+}
+
+// src/readBody.ts
+var import_promises2 = require("fs/promises");
+async function readBody(bodySource, stdin = process.stdin) {
+  if (!bodySource) return void 0;
+  let text;
+  if (bodySource.kind === "inline") {
+    text = bodySource.text;
+  } else if (bodySource.kind === "file") {
+    text = await (0, import_promises2.readFile)(bodySource.path, "utf8");
+  } else {
+    text = await collectStream(stdin);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`--body is not valid JSON: ${msg}`);
+  }
+}
+async function collectStream(s) {
+  const chunks = [];
+  for await (const chunk of s) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/cli.ts
+var CLI_VERSION = "1.0.0";
+var SPEC_URL_DEFAULT = "https://ultranetwork.co/api/v1/openapi.json";
+async function run(deps = {}) {
+  const argv = deps.argv ?? process.argv.slice(2);
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  const stdin = deps.stdin ?? process.stdin;
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (err) {
+    stderr.write(`Error: ${err.message}
+`);
+    return 3;
+  }
+  const specSource = parsed.global.spec || (env.ULTRA_API_SPEC || SPEC_URL_DEFAULT).trim();
+  const tagFilter = (env.ULTRA_API_TAGS || "").split(",").map((t) => t.trim()).filter(Boolean);
+  let doc;
+  try {
+    doc = deps.specOverride ?? await loadSpec(specSource);
+  } catch (err) {
+    stderr.write(`Failed to load OpenAPI spec from ${specSource}: ${err.message}
+`);
+    return 4;
+  }
+  const operations = extractOperations(doc, { tagFilter });
+  const opsByName = new Map(operations.map((o) => [o.name, o]));
+  if (parsed.kind === "help") {
+    stdout.write(renderTopLevelHelp(operations));
+    stdout.write("\n");
+    return 0;
+  }
+  if (parsed.kind === "version") {
+    stdout.write(renderVersion(CLI_VERSION, doc.info?.version));
+    stdout.write("\n");
+    return 0;
+  }
+  if (parsed.kind === "command-help") {
+    const op2 = opsByName.get(parsed.command);
+    if (!op2) return unknownCommand(parsed.command, operations, stderr);
+    stdout.write(renderCommandHelp(op2));
+    stdout.write("\n");
+    return 0;
+  }
+  const op = opsByName.get(parsed.command);
+  if (!op) return unknownCommand(parsed.command, operations, stderr);
+  const apiKey = (env.ULTRA_API_KEY || "").trim();
+  if (!apiKey && !parsed.global.quiet) {
+    stderr.write("[ultra] WARNING: ULTRA_API_KEY is not set \u2014 call will likely 401.\n");
+  }
+  let args;
+  try {
+    args = coerceArgs(parsed.flags, op.inputSchema);
+  } catch (err) {
+    stderr.write(`Argument error: ${err.message}
+`);
+    return 3;
+  }
+  try {
+    const body = await readBody(parsed.bodySource, stdin);
+    if (body !== void 0) args.body = body;
+  } catch (err) {
+    stderr.write(`Body error: ${err.message}
+`);
+    return 3;
+  }
+  if (op.hasBody && args.body === void 0 && requiresBody(op)) {
+    stderr.write(`This command requires --body=<json|@file|->. Run \`ultra ${op.name} --help\`.
+`);
+    return 3;
+  }
+  const baseUrl = parsed.global.baseUrl || (env.ULTRA_API_BASE_URL || "").trim() || doc.servers?.[0]?.url || "https://ultranetwork.co/api/v1";
+  let result;
+  try {
+    result = await executeOperation(
+      op,
+      args,
+      { baseUrl, apiKey: apiKey || void 0, userAgent: `ultra-cli/${CLI_VERSION}` },
+      deps.fetchImpl
+    );
+  } catch (err) {
+    stderr.write(`Network error: ${err.message}
+`);
+    return 2;
+  }
+  if (parsed.global.status && !parsed.global.quiet) {
+    stderr.write(`HTTP ${result.status}${result.request_id ? ` (request_id=${result.request_id})` : ""}
+`);
+  }
+  if (parsed.global.raw) {
+    const text = typeof result.body === "string" ? result.body : JSON.stringify(result.body);
+    stdout.write(text);
+    stdout.write("\n");
+  } else {
+    stdout.write(JSON.stringify(result.body, null, 2));
+    stdout.write("\n");
+  }
+  if (result.status >= 500) return 2;
+  if (result.status >= 400) return 1;
+  return 0;
+}
+function unknownCommand(name, operations, stderr) {
+  stderr.write(`Unknown command: ${name}
+`);
+  const suggestions = operations.map((o) => o.name).filter((n) => n.startsWith(name.slice(0, Math.max(3, Math.floor(name.length / 2))))).slice(0, 5);
+  if (suggestions.length) {
+    stderr.write(`Did you mean: ${suggestions.join(", ")}?
+`);
+  }
+  stderr.write("Run `ultra --help` to list commands.\n");
+  return 3;
+}
+function requiresBody(op) {
+  const required = op.inputSchema.required ?? [];
+  return required.includes("body");
+}
+var isDirect = typeof require !== "undefined" && require.main === module;
+if (isDirect) {
+  run().then(
+    (code) => {
+      process.exit(code);
+    },
+    (err) => {
+      process.stderr.write(`[ultra] fatal: ${err.message}
+`);
+      process.exit(2);
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});
+//# sourceMappingURL=cli.cjs.map