@asteroidai/cli 1.9.12 → 1.9.28

package/src/http.ts

@@ -1,115 +0,0 @@
-import { type Auth, UNSET_API_KEY } from "./auth/credentials";
-import type { BuiltRequest } from "./request";
-
-export class ApiError extends Error {
-  constructor(
-    readonly status: number,
-    message: string,
-    readonly body: unknown,
-  ) {
-    super(message);
-  }
-}
-
-export interface ApiResponse {
-  status: number;
-  json?: unknown;
-  text?: string;
-  bytes?: Uint8Array;
-}
-
-export const VERSION = process.env.ASTEROID_CLI_VERSION ?? "dev";
-
-function problem(status: number, body: unknown, fallback: string): string {
-  if (body && typeof body === "object") {
-    const record = body as Record<string, unknown>;
-    for (const key of ["detail", "message", "error", "title"]) {
-      if (typeof record[key] === "string" && record[key])
-        return record[key] as string;
-    }
-  }
-  return fallback.trim() || `HTTP ${status}`;
-}
-
-export async function send(
-  apiUrl: string,
-  auth: Auth,
-  request: BuiltRequest,
-  binary: boolean,
-  fetchImpl: typeof fetch = fetch,
-): Promise<ApiResponse> {
-  const query = request.query.toString();
-  const url = `${apiUrl}${request.path}${query ? `?${query}` : ""}`;
-  const headers: Record<string, string> = {
-    ...auth.headers,
-    Accept: binary ? "*/*" : "application/json",
-    "User-Agent": `asteroid-cli/${VERSION}`,
-    "X-Request-Source": "asteroid-cli",
-  };
-  let body: BodyInit | undefined;
-  if (request.form) body = request.form;
-  else if (request.json !== undefined) {
-    headers["Content-Type"] = "application/json";
-    body = JSON.stringify(request.json);
-  }
-
-  let response = await fetchImpl(url, {
-    method: request.method,
-    headers,
-    body,
-    redirect: "manual",
-  });
-  let current = new URL(url);
-  let hopHeaders: Record<string, string> = { ...headers };
-  let method: string = request.method;
-  for (let hop = 0; hop < 5; hop++) {
-    const location = response.headers.get("location");
-    if (response.status < 300 || response.status >= 400 || !location) break;
-    const target = new URL(location, current);
-    if (target.origin !== current.origin) {
-      hopHeaders = { "User-Agent": headers["User-Agent"] };
-      if (headers["Content-Type"])
-        hopHeaders["Content-Type"] = headers["Content-Type"];
-    }
-    current = target;
-    const keepMethod = response.status === 307 || response.status === 308;
-    if (!keepMethod && method !== "HEAD") {
-      method = "GET";
-      body = undefined;
-      delete hopHeaders["Content-Type"];
-    }
-    response = await fetchImpl(target, {
-      method,
-      headers: hopHeaders,
-      body,
-      redirect: "manual",
-    });
-  }
-  const contentType = response.headers.get("content-type") ?? "";
-
-  if (!response.ok) {
-    const text = await response.text();
-    let parsed: unknown = text;
-    try {
-      parsed = JSON.parse(text);
-    } catch {
-      parsed = text;
-    }
-    let message = problem(response.status, parsed, text.slice(0, 200));
-    const sentKey = "X-Api-Key" in hopHeaders;
-    if (sentKey && response.status === 401)
-      message = `ASTEROID_API_KEY was rejected: ${message}. Check the key. ${UNSET_API_KEY}`;
-    else if (sentKey && response.status === 403)
-      message = `${message} (sent with ASTEROID_API_KEY. ${UNSET_API_KEY})`;
-    throw new ApiError(response.status, message, parsed);
-  }
-  if (binary)
-    return {
-      status: response.status,
-      bytes: new Uint8Array(await response.arrayBuffer()),
-    };
-  if (response.status === 204) return { status: 204 };
-  if (contentType.includes("json"))
-    return { status: response.status, json: await response.json() };
-  return { status: response.status, text: await response.text() };
-}

package/src/main.ts

@@ -1,49 +0,0 @@
-import { spawn } from "node:child_process";
-
-import { ALL_COMMANDS } from "./commands";
-import { readEnv } from "./config";
-import { runCompletion } from "./program";
-import { BUILTINS } from "./reference";
-import { run } from "./run";
-import { clackUi } from "./ui";
-
-function openUrl(url: string) {
-  if (process.env.ASTEROID_NO_BROWSER || !/^https:\/\/[^\s"'<>^&|]+$/.test(url))
-    return;
-  const [command, args] =
-    process.platform === "darwin"
-      ? ["open", [url]]
-      : process.platform === "win32"
-        ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
-        : ["xdg-open", [url]];
-  try {
-    spawn(command, args, { stdio: "ignore", detached: true })
-      .on("error", () => undefined)
-      .unref();
-  } catch {
-    return;
-  }
-}
-
-const argv = process.argv.slice(2);
-if (argv[0] === "complete") {
-  await runCompletion(argv, { commands: ALL_COMMANDS, builtins: BUILTINS });
-  process.exit(0);
-}
-
-const code = await run(argv, {
-  env: readEnv(),
-  cwd: process.cwd(),
-  fetch,
-  stdout: (text) => process.stdout.write(text),
-  stderr: (text) => process.stderr.write(text),
-  writeBytes: (bytes) => process.stdout.write(bytes),
-  ui: process.stdin.isTTY && process.stderr.isTTY ? clackUi : undefined,
-  stdoutIsTTY: process.stdout.isTTY === true,
-  styled:
-    process.stdout.isTTY === true &&
-    !process.env.NO_COLOR &&
-    process.env.TERM !== "dumb",
-  openUrl,
-});
-process.exitCode = code;

package/src/output.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { clean, render } from "./output";
-
-describe("clean", () => {
-  it("strips escape sequences and control characters, keeps newlines and tabs", () => {
-    const hostile =
-      "a\u001b[31mred\u001b[0m\u001b]0;title\u0007b\rc\u0008d\te\nf\u009bg";
-    expect(clean(hostile)).toBe("aredbcd\te\nfg");
-  });
-});
-
-describe("render", () => {
-  it("cleans server text in tables and records", () => {
-    const plain = render({ items: [{ id: "1", name: "x\u001b[2Jy" }] });
-    expect(plain).toContain("xy");
-    expect(plain).not.toContain("\u001b");
-    expect(render({ note: "a\u0007b" })).toContain("ab");
-  });
-
-  it("draws a bordered table only when styled", () => {
-    const rows = [{ id: "1", name: "Ada" }];
-    expect(render(rows)).not.toContain("┌");
-    expect(render(rows, { styled: true })).toContain("┌");
-  });
-
-  it("prints nested objects in full, not as cut JSON", () => {
-    const out = render({
-      workflow: { id: "3cfc3c1d-e38d-4132-a5ee-8847136d491d", name: "Nebula" },
-      version: { version: 3, isPublished: true },
-    });
-    expect(out).toContain("3cfc3c1d-e38d-4132-a5ee-8847136d491d");
-    expect(out).toMatch(/workflow:\n {2}id +3cfc3c1d/);
-    expect(out).not.toContain("…");
-  });
-
-  it("flattens one level of nested fields into table columns", () => {
-    const out = render([
-      { date: "2026-10-09", outcomes: { success: 3, failure: 1 } },
-    ]);
-    expect(out).toContain("OUTCOMES.SUCCESS");
-    expect(out).toMatch(/2026-10-09 +3 +1/);
-  });
-
-  it("hides nested fields that are hidden at the top level", () => {
-    const out = render([
-      { id: "1", execution: { agentId: "a-1", status: "failed" } },
-    ]);
-    expect(out).toContain("EXECUTION.STATUS");
-    expect(out).not.toContain("AGENTID");
-  });
-
-  it("keeps long cells whole when asked", () => {
-    const secrets = `ECW(51d1db07-a6e1-4b1d-8303-a472b78923e8)[PASSWORD=##ECW_PASSWORD##]`;
-    const rows = [{ id: "p-1", secrets }];
-    expect(render(rows)).toContain("…");
-    expect(render(rows, { full: true })).toContain(secrets);
-  });
-
-  it("shows every column when asked, six otherwise", () => {
-    const row = Object.fromEntries(
-      ["id", "a", "b", "c", "d", "e", "f", "g"].map((key) => [
-        key,
-        key.toUpperCase(),
-      ]),
-    );
-    const header = (out: string) => out.split("\n")[0].trim().split(/\s+/);
-    expect(header(render([row]))).toHaveLength(6);
-    expect(header(render([row], { full: true }))).toHaveLength(8);
-  });
-});

package/src/output.ts

@@ -1,176 +0,0 @@
-import Table from "cli-table3";
-import { styleText } from "node:util";
-
-const PREFERRED = [
-  "id",
-  "name",
-  "title",
-  "workflowName",
-  "status",
-  "outcome",
-  "version",
-  "createdAt",
-  "updatedAt",
-];
-const HIDDEN = /^agent[A-Z]|Url$/;
-const MAX_COLUMNS = 6;
-const MAX_CELL = 60;
-const CONTROL =
-  /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[@-_]?|[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
-
-type Row = Record<string, unknown>;
-
-export interface RenderOptions {
-  styled?: boolean;
-  full?: boolean;
-}
-
-export function clean(text: string): string {
-  return text.replace(CONTROL, "");
-}
-
-function isObject(value: unknown): boolean {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isScalar(value: unknown): boolean {
-  return (
-    value === null || ["string", "number", "boolean"].includes(typeof value)
-  );
-}
-
-function indent(text: string): string {
-  return text
-    .split("\n")
-    .map((line) => `  ${line}`)
-    .join("\n");
-}
-
-function text(value: unknown): string {
-  return clean(isScalar(value) ? String(value) : JSON.stringify(value));
-}
-
-function cell(value: unknown, options: RenderOptions = {}): string {
-  if (value === null || value === undefined) return "";
-  const line = text(value).replace(/\s+/g, " ");
-  if (options.full || line.length <= MAX_CELL) return line;
-  return `${line.slice(0, MAX_CELL - 1)}…`;
-}
-
-function columns(rows: Row[], options: RenderOptions): string[] {
-  const scalarKeys: string[] = [];
-  for (const row of rows) {
-    for (const [key, value] of Object.entries(row)) {
-      if (
-        isScalar(value) &&
-        !HIDDEN.test(key.split(".").at(-1) ?? key) &&
-        !scalarKeys.includes(key)
-      )
-        scalarKeys.push(key);
-    }
-  }
-  const ordered = [
-    ...PREFERRED.filter((key) => scalarKeys.includes(key)),
-    ...scalarKeys.filter((key) => !PREFERRED.includes(key)),
-  ];
-  return options.full ? ordered : ordered.slice(0, MAX_COLUMNS);
-}
-
-function style(
-  format: Parameters<typeof styleText>[0],
-  value: string,
-  options: RenderOptions,
-) {
-  return options.styled
-    ? styleText(format, value, { validateStream: false })
-    : value;
-}
-
-function flatten(row: Row): Row {
-  const flat: Row = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (!isObject(value)) {
-      flat[key] = value;
-      continue;
-    }
-    for (const [inner, v] of Object.entries(value as Row))
-      flat[`${key}.${inner}`] = v;
-  }
-  return flat;
-}
-
-export function table(input: Row[], options: RenderOptions = {}): string {
-  if (input.length === 0) return "No results.";
-  const rows = input.map(flatten);
-  const keys = columns(rows, options);
-  if (keys.length === 0) return rows.map((row) => text(row)).join("\n");
-  const cells = rows.map((row) => keys.map((key) => cell(row[key], options)));
-  if (options.styled) {
-    const grid = new Table({
-      head: keys.map((key) => style("bold", key, options)),
-      style: { head: [], border: [] },
-    });
-    grid.push(...cells);
-    return grid.toString();
-  }
-  const widths = keys.map((key, i) =>
-    Math.max(key.length, ...cells.map((r) => r[i].length)),
-  );
-  const line = (values: string[]) =>
-    values
-      .map((v, i) => v.padEnd(widths[i]))
-      .join("  ")
-      .trimEnd();
-  return [line(keys.map((k) => k.toUpperCase())), ...cells.map(line)].join(
-    "\n",
-  );
-}
-
-function summary(value: unknown, options: RenderOptions): string {
-  if (Array.isArray(value))
-    return `[${value.length} item${value.length === 1 ? "" : "s"}]`;
-  if (value && typeof value === "object") return cell(value, options);
-  return text(value);
-}
-
-function record(value: Row, options: RenderOptions): string {
-  const width = Math.max(...Object.keys(value).map((key) => key.length));
-  const label = (key: string) => style("bold", key.padEnd(width), options);
-  return Object.entries(value)
-    .map(([key, v]) => {
-      if (Array.isArray(v) && v.length > 0 && v.every(isObject)) {
-        return `${style("bold", key, options)}:\n${indent(table(v as Row[], options))}`;
-      }
-      if (Array.isArray(v) && v.length > 0 && v.every(isScalar)) {
-        return `${label(key)}  ${v.map(text).join(`\n${" ".repeat(width + 2)}`)}`;
-      }
-      if (isObject(v) && Object.keys(v as Row).length > 0) {
-        return `${style("bold", key, options)}:\n${indent(record(v as Row, options))}`;
-      }
-      return `${label(key)}  ${isScalar(v) ? text(v) : summary(v, options)}`;
-    })
-    .join("\n");
-}
-
-export function render(value: unknown, options: RenderOptions = {}): string {
-  if (value === undefined) return "";
-  if (Array.isArray(value)) {
-    return value.every(isObject)
-      ? table(value as Row[], options)
-      : value.map(text).join("\n");
-  }
-  if (isObject(value)) {
-    const row = value as Row;
-    if (Array.isArray(row.items)) {
-      const rest = Object.entries(row).filter(
-        ([k, v]) => k !== "items" && isScalar(v),
-      );
-      const footer = rest.length
-        ? `\n\n${style("dim", rest.map(([k, v]) => `${k}: ${text(v)}`).join("  "), options)}`
-        : "";
-      return `${table(row.items as Row[], options)}${footer}`;
-    }
-    return record(row, options);
-  }
-  return text(value);
-}

package/src/program.test.ts

@@ -1,155 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { COMMANDS } from "./generated/commands";
-import { type Invocation, parseInvocation } from "./program";
-import { BUILTINS } from "./reference";
-
-const parse = (argv: string[]) =>
-  parseInvocation(argv, { commands: COMMANDS, builtins: BUILTINS });
-
-function command(invocation: Invocation) {
-  if (invocation.kind !== "command")
-    throw new Error(`expected a command, got ${invocation.kind}`);
-  return invocation;
-}
-
-describe("parseInvocation", () => {
-  it("collects repeated flags, globals anywhere, and positionals", async () => {
-    const got = command(
-      await parse([
-        "--json",
-        "execution",
-        "list",
-        "--status",
-        "failed",
-        "--status",
-        "completed",
-        "--org",
-        "acme",
-      ]),
-    );
-    expect(got.command.tool).toBe("executions_list");
-    expect(got.parsed.flags.get("status")).toEqual(["failed", "completed"]);
-    expect(got.parsed.json).toBe(true);
-    expect(got.parsed.org).toBe("acme");
-  });
-
-  it("keeps dotted body flags for the request builder", async () => {
-    const got = command(
-      await parse([
-        "workflow",
-        "execute",
-        "w-1",
-        "--execution-options.variant-key",
-        "canary",
-      ]),
-    );
-    expect(got.parsed.positionals).toEqual(["w-1"]);
-    expect(got.parsed.flags.get("execution-options.variant-key")).toEqual([
-      "canary",
-    ]);
-  });
-
-  it("rejects a dotted flag no body field owns", async () => {
-    await expect(
-      parse(["workflow", "list", "--nope.deep", "1"]),
-    ).rejects.toThrow(/unknown flag: --nope.deep/);
-  });
-
-  it("reads --no-<flag> as false", async () => {
-    const got = command(
-      await parse(["schedule", "update", "w-1", "s-1", "--no-enabled"]),
-    );
-    expect(got.parsed.flags.get("enabled")).toEqual(["false"]);
-  });
-
-  it("routes account commands as builtins and checks their arguments", async () => {
-    const use = await parse(["use", "acme"]);
-    expect(use).toMatchObject({ kind: "builtin", name: "use" });
-    expect(await parse(["use", "a", "b"])).toMatchObject({
-      kind: "exit",
-      code: 2,
-    });
-    expect(await parse(["logout", "--typo", "x"])).toMatchObject({
-      kind: "exit",
-      code: 2,
-    });
-  });
-
-  it("shows group and command help with exit 0", async () => {
-    const group = await parse(["workflow", "version"]);
-    expect(group).toMatchObject({ kind: "exit", code: 0 });
-    expect(group.kind === "exit" && group.stdout + group.stderr).toContain(
-      "publish",
-    );
-    const leaf = await parse(["workflow", "get", "--help"]);
-    expect(leaf.kind === "exit" && leaf.stdout).toContain("<workflow-id>");
-  });
-
-  it("fills a defaulted first argument when it is left out", async () => {
-    const got = command(
-      await parseInvocation(["workflow", "tag", "list"], {
-        commands: COMMANDS,
-        defaultArg: (_, arg) =>
-          arg.name === "workflowId" ? "chat-wf" : undefined,
-      }),
-    );
-    expect(got.parsed.positionals).toEqual(["chat-wf"]);
-  });
-
-  it("adds a per-command help note", async () => {
-    const help = await parseInvocation(["workflow", "get", "--help"], {
-      commands: COMMANDS,
-      helpNote: (command) =>
-        command.tool === "workflow_get" ? "Note for get." : undefined,
-    });
-
-    expect(help.kind === "exit" && help.stdout).toContain("Note for get.");
-  });
-
-  it("fills a defaulted first argument ahead of a required one", async () => {
-    const options = {
-      commands: COMMANDS,
-      defaultArg: (_: unknown, arg: { name: string }) =>
-        arg.name === "workflowId" ? "chat-wf" : undefined,
-    };
-
-    const short = command(
-      await parseInvocation(["schedule", "get", "s-1"], options),
-    );
-    expect(short.parsed.positionals).toEqual(["chat-wf", "s-1"]);
-
-    const full = command(
-      await parseInvocation(["schedule", "get", "wf-2", "s-1"], options),
-    );
-    expect(full.parsed.positionals).toEqual(["wf-2", "s-1"]);
-
-    const help = await parseInvocation(["schedule", "get", "--help"], options);
-    expect(help.kind === "exit" && help.stdout).toContain(
-      "[workflow-id] <schedule-id>",
-    );
-
-    await expect(parseInvocation(["schedule", "get"], options)).rejects.toThrow(
-      "expected [workflow-id] <schedule-id>, got 0 argument(s)",
-    );
-  });
-
-  it("prints the version only as the first argument", async () => {
-    const options = {
-      commands: COMMANDS,
-      builtins: BUILTINS,
-      version: "1.2.3",
-    };
-
-    const version = await parseInvocation(["--version"], options);
-    const create = await parseInvocation(
-      ["workflow", "create", "--name", "W", "--version", "{}"],
-      options,
-    );
-
-    expect(version).toMatchObject({ kind: "exit", code: 0, stdout: "1.2.3\n" });
-    expect(create.kind).toBe("command");
-    if (create.kind === "command")
-      expect(create.parsed.flags.get("version")).toEqual(["{}"]);
-  });
-});