@allocator-one/infraone 0.0.0-stage → 1.17.1

package/dist/infraone.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+import {
+  guardBrokenPipes,
+  runOperatorMount
+} from "./chunk-67NX7MJ2.js";
+import {
+  InfraoneClient,
+  commandSpecs,
+  describeSession,
+  loadSpec,
+  login,
+  logout,
+  mountCommands,
+  refreshSpec,
+  resolveConfig,
+  transferFor,
+  whoami
+} from "./chunk-XA5UDNJI.js";
+import "./chunk-WSDFLMO6.js";
+import {
+  CommandError,
+  HttpError,
+  LocalError,
+  TransportError,
+  UsageError,
+  clean,
+  table
+} from "./chunk-BHBEIT5I.js";
+import {
+  CLI_VERSION
+} from "./chunk-5THYIKLW.js";
+
+// src/infraone/cli.ts
+import { createInterface } from "readline";
+import { Command, CommanderError } from "commander";
+
+// src/infraone/run.ts
+import { randomUUID } from "crypto";
+
+// src/infraone/output.ts
+var MAX_COLUMNS = 6;
+var LEADING = ["id", "name", "title", "type", "kind", "status", "role", "email"];
+function render(data, schema) {
+  if (Array.isArray(data)) return renderList(data, schema?.type === "array" ? schema.items ?? null : schema);
+  if (isRecord(data)) return renderRecord(data, schema);
+  if (data === null || data === void 0) return "";
+  return `${clean(data)}
+`;
+}
+function renderList(rows, itemSchema) {
+  if (rows.length === 0) return "No results.\n";
+  const records = rows.filter(isRecord);
+  if (records.length !== rows.length) return rows.map((row) => `${cell(row)}
+`).join("");
+  const columns = listColumns(records, itemSchema);
+  if (columns.length === 0) return rows.map((row) => `${cell(row)}
+`).join("");
+  return table(
+    columns.map((column) => column.toUpperCase()),
+    records.map((record) => columns.map((column) => cell(record[column])))
+  );
+}
+function renderRecord(record, schema) {
+  const keys = ordered([.../* @__PURE__ */ new Set([...Object.keys(schema?.properties ?? {}), ...Object.keys(record)])]).filter(
+    (key) => key in record
+  );
+  if (keys.length === 0) return "";
+  const width = Math.max(...keys.map((key) => key.length));
+  return keys.map((key) => `${key.padEnd(width)}  ${cell(record[key])}
+`).join("");
+}
+function listColumns(records, itemSchema) {
+  const fromSchema = Object.entries(itemSchema?.properties ?? {}).filter(([, property]) => property.type !== "object" && property.type !== "array").map(([name]) => name);
+  const candidates = fromSchema.length > 0 ? fromSchema : [...new Set(records.flatMap((record) => Object.keys(record)))].filter(
+    (key) => records.some((record) => isScalar(record[key]))
+  );
+  return ordered(candidates).slice(0, MAX_COLUMNS);
+}
+function ordered(keys) {
+  const leading = LEADING.filter((key) => keys.includes(key));
+  const rest = keys.filter((key) => !LEADING.includes(key));
+  return [...leading, ...rest.filter((key) => !key.endsWith("_id")), ...rest.filter((key) => key.endsWith("_id"))];
+}
+function cell(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return clean(JSON.stringify(value));
+  return clean(value);
+}
+function isScalar(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/infraone/run.ts
+var NEVER_SENT = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "CERT_HAS_EXPIRED", "DEPTH_ZERO_SELF_SIGNED_CERT", "SELF_SIGNED_CERT_IN_CHAIN", "UNABLE_TO_VERIFY_LEAF_SIGNATURE", "ERR_TLS_CERT_ALTNAME_INVALID"]);
+var MAX_PAGES = 1e4;
+async function runOperation(context, command, invocation) {
+  if (!context.signedIn) throw new UsageError(context.loginHint);
+  const path = command.path.replace(/\{([a-z][a-z0-9_]*)\}/g, (_, name) => {
+    const value = invocation.pathValues[name];
+    if (value === void 0 || value === "") throw new UsageError(`${name} must not be empty`);
+    if (value === "." || value === "..") throw new UsageError(`${name} cannot be ${value}`);
+    return encodeURIComponent(value);
+  });
+  const confirmed = await confirm(context, command, invocation);
+  const writes = command.risk !== "read";
+  if (writes) context.stderr(`\u2192 ${await context.target()}
+`);
+  let data;
+  const transfer = transferFor(command);
+  if (transfer !== null) {
+    data = await transfer.run({
+      client: context.client,
+      command,
+      invocation,
+      path,
+      operations: context.operations,
+      confirmed,
+      interactive: context.interactive,
+      prompt: context.prompt,
+      target: context.target,
+      stderr: context.stderr
+    });
+  } else {
+    data = await send(context, command, path, invocation, confirmed, writes);
+  }
+  if (invocation.json) {
+    context.stdout(JSON.stringify(data ?? null) + "\n");
+    return;
+  }
+  const human = render(data, command.paged ? { type: "array", ...command.dataSchema === null ? {} : { items: command.dataSchema } } : command.dataSchema);
+  context.stdout(human === "" && writes ? "Done.\n" : human);
+}
+async function confirm(context, command, invocation) {
+  if (command.risk !== "destructive" && command.risk !== "outward") return false;
+  if (invocation.yes) return true;
+  const name = command.words.join(" ");
+  if (!context.interactive) {
+    throw new UsageError(
+      `${name} is ${article(command.risk)} ${command.risk} operation and needs your confirmation: run it at a terminal, or pass --yes \u2014 nothing was sent`
+    );
+  }
+  const what = command.risk === "destructive" ? "It deletes or revokes something" : "It reaches people outside Infra One";
+  const answer = await context.prompt(`${clean(command.summary || name)} \u2014 ${what}, in ${await context.target()}. Continue? [y/N] `);
+  if (!/^y(es)?$/i.test(answer.trim())) throw new LocalError("cancelled \u2014 nothing was sent");
+  return true;
+}
+async function send(context, command, path, invocation, confirmed, writes) {
+  const request = async (query) => {
+    let answer2;
+    try {
+      answer2 = await context.client.request(command.method, path, {
+        query,
+        body: invocation.body,
+        confirmed,
+        ...writes ? { idempotencyKey: randomUUID() } : {}
+      });
+    } catch (error) {
+      if (writes && error instanceof TransportError && !NEVER_SENT.has(error.code ?? "")) {
+        throw new CommandError(
+          `outcome unknown: the write may have reached the API (${error.message}) \u2014 check before running it again`
+        );
+      }
+      throw error;
+    }
+    context.observe(answer2);
+    return answer2;
+  };
+  const first = await request(invocation.query);
+  if (!command.paged) return first.body["data"];
+  const rows = [];
+  let answer = first;
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 1; ; page++) {
+    const data = answer.body["data"];
+    if (!Array.isArray(data)) throw new CommandError("the API answered a list with no data list");
+    rows.push(...data);
+    const next = nextCursor(answer);
+    if (next === null) return rows;
+    if (!invocation.all) {
+      context.stderr(`More results: --cursor ${clean(next)} for the next page, or --all for every page.
+`);
+      return rows;
+    }
+    if (seen.has(next) || page >= MAX_PAGES) throw new CommandError("the API kept answering with more pages \u2014 stopped");
+    seen.add(next);
+    answer = await request({ ...invocation.query, cursor: next });
+  }
+}
+function nextCursor(answer) {
+  const meta = answer.body["meta"];
+  if (typeof meta !== "object" || meta === null) return null;
+  const next = meta["next_cursor"];
+  return typeof next === "string" && next !== "" ? next : null;
+}
+function article(word) {
+  return /^[aeiou]/.test(word) ? "an" : "a";
+}
+
+// src/infraone/cli.ts
+var PREFIX = "infraone: ";
+async function run(args, io) {
+  const resolved = resolveConfig(io.env);
+  if (!resolved.ok) {
+    io.stderr(PREFIX + resolved.message + "\n");
+    return 2;
+  }
+  const config = resolved.config;
+  const client = new InfraoneClient(config.apiUrl, config.token, io.fetchImpl);
+  if (args.length === 0) {
+    const program = buildProgram(config, client, await loadSpec(config), io, { observed: null });
+    program.outputHelp({ error: true });
+    return 2;
+  }
+  let loaded = await loadSpec(config);
+  const state = { observed: null };
+  let code = await attempt(buildProgram(config, client, loaded, io, state), args, io, true);
+  if (code === UNKNOWN_COMMAND) {
+    loaded = await refreshSpec(config, client) ?? loaded;
+    code = await attempt(buildProgram(config, client, loaded, io, state), args, io, false);
+  }
+  if (state.observed !== null && state.observed !== loaded.fingerprint) await refreshSpec(config, client);
+  return code;
+}
+var UNKNOWN_COMMAND = -1;
+async function attempt(program, args, io, quietUnknown) {
+  const errors = [];
+  program.configureOutput({
+    writeOut: io.stdout,
+    // Held back on a first attempt, so an unknown command that a fresher
+    // spec knows prints nothing about the miss.
+    writeErr: (text) => quietUnknown ? errors.push(text) : io.stderr(text),
+    outputError: (text, write) => write(text)
+  });
+  for (const command of allCommands(program)) command.configureOutput(program.configureOutput());
+  try {
+    await program.parseAsync(args, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (quietUnknown && error.code === "commander.unknownCommand") return UNKNOWN_COMMAND;
+      for (const text of errors) io.stderr(text);
+      if (error.code === "commander.helpDisplayed" || error.code === "commander.version") return 0;
+      return 2;
+    }
+    for (const text of errors) io.stderr(text);
+    return reportError(error, io);
+  }
+}
+function reportError(error, io) {
+  if (error instanceof UsageError) {
+    io.stderr(PREFIX + clean(error.message) + "\n");
+    return 2;
+  }
+  if (error instanceof HttpError) {
+    const requestId = typeof error.body["request_id"] === "string" ? ` (request ${clean(error.body["request_id"])})` : "";
+    const approval = approvalUrl(error.body);
+    io.stderr(
+      `${PREFIX}${clean(error.message)}${requestId}
+` + (approval === null ? "" : `Approve it at ${clean(approval)}, then run the command again.
+`)
+    );
+    return 1;
+  }
+  if (error instanceof TransportError) {
+    io.stderr(`${PREFIX}cannot reach the API: ${clean(error.message)}
+`);
+    return 3;
+  }
+  if (error instanceof LocalError || error instanceof CommandError) {
+    io.stderr(PREFIX + clean(error.message) + "\n");
+    return 1;
+  }
+  throw error;
+}
+function approvalUrl(body) {
+  const pending = body["confirmation"];
+  const url = typeof pending === "object" && pending !== null ? pending["approval_url"] : body["approval_url"];
+  return typeof url === "string" && url !== "" ? url : null;
+}
+function buildProgram(config, client, loaded, io, state) {
+  const program = new Command("infraone").description("Infra One from the terminal: your data rooms, with exactly your app rights").exitOverride().helpCommand(true);
+  let target = null;
+  const operations = commandSpecs(loaded.spec);
+  const context = {
+    client,
+    signedIn: config.token !== null,
+    loginHint: `not signed in to ${config.apiUrl}: run \`infraone login\`, or set INFRAONE_TOKEN for scripts`,
+    stdout: io.stdout,
+    stderr: io.stderr,
+    interactive: io.interactive,
+    prompt: io.prompt,
+    target: () => target ??= writeTarget(config, client),
+    observe: (answer) => {
+      if (answer.fingerprint !== null) state.observed = answer.fingerprint;
+    },
+    operations
+  };
+  mountCommands(program, operations, (command, invocation) => runOperation(context, command, invocation));
+  const general = "General:";
+  program.command("login").description("sign in to Infra One in the browser and store the credential").option("--no-browser", "print the sign-in link and paste the token instead").option("--json", "print the result as JSON").helpGroup(general).action(async (options) => {
+    finish(await login(config, { noBrowser: !options.browser, fetchImpl: io.fetchImpl, openBrowser: io.openBrowser, notify: (line) => io.stderr(line + "\n"), prompt: () => io.prompt("Token: "), interactive: io.interactive, env: io.env }), options.json === true, io);
+  });
+  program.command("logout").description("revoke and forget the stored credential").option("--json", "print the result as JSON").helpGroup(general).action(async (options) => {
+    finish(await logout(config, { fetchImpl: io.fetchImpl, env: io.env }), options.json === true, io);
+  });
+  program.command("whoami").description("show the API, the credential and who it signs in as").option("--json", "print the result as JSON").helpGroup(general).action(async (options) => {
+    finish(await whoami(config, client), options.json === true, io);
+  });
+  program.command("version").description("show the CLI version and the spec its commands come from").option("--json", "print the result as JSON").helpGroup(general).action((options) => {
+    const apiVersion = loaded.spec.info?.version ?? null;
+    const spec = { api_version: apiVersion, source: loaded.source, fingerprint: loaded.fingerprint };
+    io.stdout(
+      options.json === true ? JSON.stringify({ cli: CLI_VERSION, api: config.apiUrl, spec }) + "\n" : `infraone ${CLI_VERSION} (API ${clean(apiVersion ?? "unknown")} at ${config.apiUrl}, spec ${loaded.source})
+`
+    );
+  });
+  program.command("mcp").description("serve Infra One's tools to an AI client over stdio (MCP), with your stored login").helpGroup(general).action(async () => {
+    const { startInfraoneMcp } = await import("./infraone-7TAHY4RN.js");
+    await startInfraoneMcp({ env: io.env, ...io.fetchImpl === void 0 ? {} : { fetchImpl: io.fetchImpl } });
+  });
+  program.command("operator").description("drive Operator: every operator command, with its own login on Harness").helpGroup(general).allowUnknownOption().allowExcessArguments().action(() => {
+    throw new UsageError("run `infraone operator \u2026` as its own command line");
+  });
+  program.commandsGroup(general).helpCommand(true);
+  return program;
+}
+async function writeTarget(config, client) {
+  const session = await describeSession(client).catch(() => null);
+  const org = session?.org;
+  const name = clean(org?.["name"] ?? org?.["slug"] ?? "");
+  return name === "" ? new URL(config.apiUrl).host : name;
+}
+function finish(result, json, io) {
+  if (result.ok) {
+    io.stdout(json ? JSON.stringify(result.json) + "\n" : result.human);
+    return;
+  }
+  throw new LocalError(result.message);
+}
+function allCommands(command) {
+  return command.commands.flatMap((child) => [child, ...allCommands(child)]);
+}
+function promptLine(question) {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    readline.question(question, (answer) => {
+      readline.close();
+      resolve(answer);
+    });
+  });
+}
+async function main(argv = process.argv.slice(2)) {
+  if (argv[0] === "operator") return runOperatorMount(argv.slice(1));
+  if (argv[0] === "help" && argv[1] === "operator") return runOperatorMount(["--help", ...argv.slice(2)]);
+  guardBrokenPipes();
+  const code = await run(argv, {
+    env: process.env,
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+    interactive: process.stdin.isTTY === true && process.stderr.isTTY === true,
+    prompt: promptLine
+  });
+  const drain = (stream) => new Promise((resolve) => stream.write("", () => resolve()));
+  await Promise.all([drain(process.stdout), drain(process.stderr)]);
+  process.exit(code);
+}
+
+// src/infraone/main.ts
+await main();