@stndrds/cli 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist/bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-// src/bin.ts
-import chalk3 from "chalk";
+// src/program.ts
+import chalk5 from "chalk";
 import { Command } from "commander";
 
 // src/client.ts
@@ -13,7 +13,9 @@ var ApiClientError = class extends Error {
   }
 };
 function buildUrl(base, path, params) {
-  const url = new URL(path, base);
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  const normalizedPath = path.replace(/^\/+/, "");
+  const url = new URL(normalizedPath, normalizedBase);
   if (params) {
     for (const [key, value] of Object.entries(params)) {
       if (value !== void 0 && value !== null) {
@@ -75,10 +77,48 @@ function createClient(config) {
 }
 
 // src/commands/auth.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
+
+// src/commands/common.ts
+function getGlobalOptions(cmd) {
+  return cmd.optsWithGlobals();
+}
+function getFormat(cmd) {
+  return getGlobalOptions(cmd).format;
+}
+function getClientFromCommand(cmd) {
+  const root = getGlobalOptions(cmd);
+  if (!(root.apiUrl && root.apiKey)) {
+    throw new Error('No Standards instance configured. Run "standards login" or pass --api-key.');
+  }
+  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+}
+
+// src/commands/auth.ts
+function registerAuthCommand(program) {
+  const auth = program.command("auth").description("Inspect CLI authentication");
+  auth.command("whoami").description("Show current configuration and validate API key").action(async (_opts, cmd) => {
+    const root = getGlobalOptions(cmd);
+    const client = getClientFromCommand(cmd);
+    const write = (msg) => process.stdout.write(`${msg}
+`);
+    write(chalk.bold("Standards CLI Configuration"));
+    write(`  API URL:  ${root.apiUrl}`);
+    write(`  API Key:  ${root.apiKey ? `${root.apiKey.slice(0, 8)}...` : chalk.red("not set")}`);
+    write("");
+    const keys = await client.get("/api-keys");
+    write(chalk.green("\u2713 API key is valid"));
+    if (Array.isArray(keys) && keys.length > 0) {
+      const activeKeys = keys.filter(
+        (key) => typeof key === "object" && key !== null && !("revokedAt" in key && key.revokedAt)
+      );
+      write(`  Active keys: ${activeKeys.length}`);
+    }
+  });
+}
 
 // src/output.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import Table from "cli-table3";
 var MAX_CELL_WIDTH = 50;
 function truncate(value, maxLength) {
@@ -107,7 +147,7 @@ function formatTable(items) {
   if (items.length === 0) return "No results.";
   const headers = Object.keys(items[0]);
   const table = new Table({
-    head: headers.map((h) => chalk.bold(h)),
+    head: headers.map((h) => chalk2.bold(h)),
     style: { head: [], border: [] }
   });
   for (const item of items) {
@@ -137,224 +177,379 @@ function formatOutput(data, format) {
 `);
 }
 
-// src/commands/auth.ts
-function getClientFromCommand(cmd) {
-  const root = cmd.optsWithGlobals();
-  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
-}
-function getFormat(cmd) {
-  return cmd.optsWithGlobals().format;
-}
-function registerAuthCommand(program2) {
-  const auth = program2.command("auth").description("Manage authentication and API keys");
-  auth.command("whoami").description("Show current configuration and validate API key").action(async (_opts, cmd) => {
-    const root = cmd.optsWithGlobals();
-    const client = getClientFromCommand(cmd);
-    const write = (msg) => process.stdout.write(`${msg}
-`);
-    write(chalk2.bold("Standards CLI Configuration"));
-    write(`  API URL:  ${root.apiUrl}`);
-    write(`  API Key:  ${root.apiKey ? `${root.apiKey.slice(0, 8)}...` : chalk2.red("not set")}`);
-    write("");
-    const keys = await client.get("/api-keys");
-    write(chalk2.green("\u2713 API key is valid"));
-    if (Array.isArray(keys) && keys.length > 0) {
-      write(`  Active keys: ${keys.length}`);
-    }
-  });
-  auth.command("create-key").description("Create a new API key").requiredOption("--name <name>", "name for the API key").option("--expires <date>", "expiration date (ISO 8601)").action(async (opts, cmd) => {
-    const client = getClientFromCommand(cmd);
-    const body = {
-      name: opts.name,
-      permissions: []
-    };
-    if (opts.expires) body.expiresAt = opts.expires;
-    const result = await client.post("/api-keys", body);
-    formatOutput(result, getFormat(cmd));
-  });
-}
-
 // src/commands/documents.ts
-function getClientFromCommand2(cmd) {
-  const root = cmd.optsWithGlobals();
-  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
-}
-function getFormat2(cmd) {
-  return cmd.optsWithGlobals().format;
-}
-function registerDocumentsCommand(program2) {
-  const documents = program2.command("documents").description("Manage documents");
+function registerDocumentsCommand(program) {
+  const documents = program.command("documents").description("Manage documents");
   documents.command("list").description("List documents").option("--status <status>", "filter by processing status").option("--limit <n>", "max documents to return").option("--offset <n>", "number of documents to skip").action(async (opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const params = {};
     if (opts.status) params.processingStatus = opts.status;
     if (opts.limit) params.limit = opts.limit;
     if (opts.offset) params.offset = opts.offset;
     const result = await client.get("/documents", params);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("get").description("Get a document by ID").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get(`/documents/${id}`);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("create").description("Create a new document").requiredOption("--title <title>", "document title").option("--values <json>", "document values as JSON string").action(async (opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const body = { title: opts.title };
     if (opts.values) body.values = JSON.parse(opts.values);
     const result = await client.post("/documents", body);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("update").description("Update a document").argument("<id>", "document ID").option("--title <title>", "new title").option("--values <json>", "new values as JSON string").action(async (id, opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const body = {};
     if (opts.title) body.title = opts.title;
     if (opts.values) body.values = JSON.parse(opts.values);
     const result = await client.patch(`/documents/${id}`, body);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("delete").description("Delete a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     await client.delete(`/documents/${id}`);
     process.stdout.write(`Document ${id} deleted.
 `);
   });
   documents.command("preview").description("Get preview file for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get(`/documents/${id}/preview`);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("slots").description("List slots for a document").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get(`/documents/${id}/slots`);
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("add-slot").description("Add a file slot to a document").argument("<id>", "document ID").requiredOption("--slot-name <name>", "slot name").requiredOption("--file-id <fileId>", "file ID").action(async (id, opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.post(`/documents/${id}/slots`, {
       slotName: opts.slotName,
       fileId: opts.fileId
     });
-    formatOutput(result, getFormat2(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   documents.command("remove-slot").description("Remove a slot from a document").argument("<id>", "document ID").argument("<slotId>", "slot ID").action(async (id, slotId, _opts, cmd) => {
-    const client = getClientFromCommand2(cmd);
+    const client = getClientFromCommand(cmd);
     await client.delete(`/documents/${id}/slots/${slotId}`);
     process.stdout.write(`Slot ${slotId} removed.
 `);
   });
 }
 
-// src/commands/records.ts
-function getClientFromCommand3(cmd) {
-  const root = cmd.optsWithGlobals();
-  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
-}
-function getFormat3(cmd) {
-  return cmd.optsWithGlobals().format;
+// src/commands/keys.ts
+import chalk3 from "chalk";
+function registerKeysCommand(program) {
+  const keys = program.command("keys").description("Manage Standards API keys");
+  keys.command("list").description("List API keys").action(async (_opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const result = await client.get("/api-keys");
+    formatOutput(result, getFormat(cmd));
+  });
+  keys.command("create").description("Create a new API key").requiredOption("--name <name>", "name for the API key").option("--expires <date>", "expiration date (ISO 8601)").option("--yes", "create without confirmation").action(async (opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Creating API keys is explicit. Re-run with "--yes" to confirm.');
+    }
+    const client = getClientFromCommand(cmd);
+    const body = {
+      name: opts.name,
+      permissions: []
+    };
+    if (opts.expires) body.expiresAt = opts.expires;
+    const result = await client.post("/api-keys", body);
+    formatOutput(result, getFormat(cmd));
+  });
+  keys.command("revoke").description("Revoke an API key").argument("<id>", "API key ID").option("--yes", "revoke without confirmation").action(async (id, opts, cmd) => {
+    if (!opts.yes) {
+      throw new Error('Revoking API keys is explicit. Re-run with "--yes" to confirm.');
+    }
+    const client = getClientFromCommand(cmd);
+    await client.delete(`/api-keys/${id}`);
+    process.stdout.write(`${chalk3.green("\u2713")} API key ${id} revoked.
+`);
+  });
 }
+
+// src/commands/records.ts
 function parseSortFlag(sort) {
   const [attribute, direction = "asc"] = sort.split(":");
   return JSON.stringify([{ attribute, direction }]);
 }
-function registerRecordsCommand(program2) {
-  const records = program2.command("records").description("Manage records (CRUD + search)");
+function registerRecordsCommand(program) {
+  const records = program.command("records").description("Manage records (CRUD + search)");
   records.command("list").description("List records for an object").argument("<object>", "object name (e.g. contacts)").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
-    const client = getClientFromCommand3(cmd);
+    const client = getClientFromCommand(cmd);
     const params = {};
     if (opts.limit) params.limit = opts.limit;
     if (opts.offset) params.offset = opts.offset;
     if (opts.sort) params.sorts = parseSortFlag(opts.sort);
     if (opts.filter) params.filters = opts.filter;
     const result = await client.get(`/records/${objectName}`, params);
-    formatOutput(result, getFormat3(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   records.command("get").description("Get a record by ID").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
-    const client = getClientFromCommand3(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get(`/records/${objectName}/${id}`);
-    formatOutput(result, getFormat3(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   records.command("create").description("Create a new record").argument("<object>", "object name").option("--data <json>", "record data as JSON string").action(async (objectName, opts, cmd) => {
     const data = opts.data ? JSON.parse(opts.data) : {};
-    const client = getClientFromCommand3(cmd);
-    const result = await client.post(`/records/${objectName}`, data);
-    formatOutput(result, getFormat3(cmd));
+    const client = getClientFromCommand(cmd);
+    const result = await client.post(`/records/${objectName}`, { data });
+    formatOutput(result, getFormat(cmd));
   });
   records.command("update").description("Update a record").argument("<object>", "object name").argument("<id>", "record ID").option("--data <json>", "fields to update as JSON string").action(async (objectName, id, opts, cmd) => {
     const data = opts.data ? JSON.parse(opts.data) : {};
-    const client = getClientFromCommand3(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.put(`/records/${objectName}/${id}`, data);
-    formatOutput(result, getFormat3(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   records.command("delete").description("Delete a record").argument("<object>", "object name").argument("<id>", "record ID").action(async (objectName, id, _opts, cmd) => {
-    const client = getClientFromCommand3(cmd);
+    const client = getClientFromCommand(cmd);
     await client.delete(`/records/${objectName}/${id}`);
     process.stdout.write(`Record ${id} deleted.
 `);
   });
   records.command("search").description("Full-text search records").argument("<object>", "object name").requiredOption("--query <q>", "search query string").option("--limit <n>", "max records to return").option("--offset <n>", "number of records to skip").option("--sort <sort>", 'sort rule as "attribute:direction"').option("--filter <json>", "filter state as JSON string").action(async (objectName, opts, cmd) => {
-    const client = getClientFromCommand3(cmd);
+    const client = getClientFromCommand(cmd);
     const params = { q: opts.query };
     if (opts.limit) params.limit = opts.limit;
     if (opts.offset) params.offset = opts.offset;
     if (opts.sort) params.sorts = parseSortFlag(opts.sort);
     if (opts.filter) params.filters = opts.filter;
     const result = await client.get(`/records/${objectName}/search`, params);
-    formatOutput(result, getFormat3(cmd));
+    formatOutput(result, getFormat(cmd));
   });
 }
 
-// src/commands/schema.ts
-function getClientFromCommand4(cmd) {
-  const root = cmd.optsWithGlobals();
-  return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey });
+// src/commands/root.ts
+import { stdin as input, stdout as output } from "process";
+import { createInterface } from "readline/promises";
+import chalk4 from "chalk";
+
+// src/config.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULT_API_URL = "http://localhost:4100/v1";
+function getDefaultApiUrl() {
+  return DEFAULT_API_URL;
 }
-function getFormat4(cmd) {
-  return cmd.optsWithGlobals().format;
+function getConfigPath() {
+  const configDir = process.env.STANDARDS_CONFIG_DIR ?? join(homedir(), ".standards");
+  return join(configDir, "config.json");
 }
-function registerSchemaCommand(program2) {
-  const schema = program2.command("schema").description("Inspect schema objects and attributes");
+async function readConfig() {
+  try {
+    const raw = await readFile(getConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      currentProfile: parsed.currentProfile,
+      profiles: parsed.profiles ?? {}
+    };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { profiles: {} };
+    }
+    throw error;
+  }
+}
+async function writeConfig(config) {
+  const path = getConfigPath();
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+async function upsertProfile(input2) {
+  const config = await readConfig();
+  config.profiles[input2.name] = {
+    apiUrl: input2.apiUrl,
+    apiKey: input2.apiKey
+  };
+  config.currentProfile = input2.name;
+  await writeConfig(config);
+}
+async function setCurrentProfile(name) {
+  const config = await readConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Unknown Standards instance "${name}"`);
+  }
+  config.currentProfile = name;
+  await writeConfig(config);
+}
+async function removeProfile(name) {
+  const config = await readConfig();
+  const profileName = name ?? config.currentProfile;
+  if (!profileName) return;
+  delete config.profiles[profileName];
+  if (config.currentProfile === profileName) {
+    config.currentProfile = void 0;
+  }
+  await writeConfig(config);
+}
+async function listProfiles() {
+  const config = await readConfig();
+  return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b)).map(([name, profile]) => ({
+    name,
+    apiUrl: profile.apiUrl,
+    current: config.currentProfile === name
+  }));
+}
+async function getActiveProfile() {
+  const config = await readConfig();
+  if (!config.currentProfile) return null;
+  const profile = config.profiles[config.currentProfile];
+  if (!profile) return null;
+  return { name: config.currentProfile, ...profile };
+}
+async function resolveCliConfig(options) {
+  if (options.apiUrl || options.apiKey) {
+    return {
+      apiUrl: options.apiUrl ?? process.env.STANDARDS_API_URL ?? DEFAULT_API_URL,
+      apiKey: options.apiKey ?? process.env.STANDARDS_API_KEY
+    };
+  }
+  const config = await readConfig();
+  const profileName = options.instance ?? config.currentProfile;
+  if (profileName) {
+    const profile = config.profiles[profileName];
+    if (!profile) throw new Error(`Unknown Standards instance "${profileName}"`);
+    return {
+      apiUrl: profile.apiUrl,
+      apiKey: profile.apiKey,
+      profileName
+    };
+  }
+  return {
+    apiUrl: process.env.STANDARDS_API_URL ?? DEFAULT_API_URL,
+    apiKey: process.env.STANDARDS_API_KEY
+  };
+}
+
+// src/commands/root.ts
+async function promptForMissingValue(label) {
+  const rl = createInterface({ input, output });
+  try {
+    const value = await rl.question(`${label}: `);
+    return value.trim();
+  } finally {
+    rl.close();
+  }
+}
+function registerRootCommands(program) {
+  program.command("login").description("Connect the CLI to a Standards instance").option("--url <url>", "Standards API URL", getDefaultApiUrl()).option("--key <key>", "API key to store for this instance").option("--name <name>", "local instance name", "local").action(async (opts) => {
+    const apiKey = opts.key ?? await promptForMissingValue("API key");
+    if (!apiKey) throw new Error("API key is required");
+    const client = createClient({ apiUrl: opts.url, apiKey });
+    await client.get("/api-keys");
+    await upsertProfile({ name: opts.name, apiUrl: opts.url, apiKey });
+    process.stdout.write(
+      `${chalk4.green("\u2713")} Standards instance "${opts.name}" saved and selected.
+`
+    );
+    process.stdout.write(`  API URL: ${opts.url}
+`);
+    process.stdout.write(`  API Key: ${apiKey.slice(0, 8)}...
+`);
+    process.stdout.write(`  Use it with: standards --instance ${opts.name} <command>
+`);
+  });
+  program.command("use").description("Select the active Standards instance").argument("<name>", "instance name").action(async (name) => {
+    await setCurrentProfile(name);
+    process.stdout.write(`${chalk4.green("\u2713")} Standards instance "${name}" selected.
+`);
+  });
+  program.command("instances").description("List configured Standards instances").action(async (_opts, cmd) => {
+    const profiles = await listProfiles();
+    formatOutput(profiles, getFormat(cmd));
+  });
+  program.command("current").description("Show the active Standards instance").action(async () => {
+    const profile = await getActiveProfile();
+    if (!profile) {
+      process.stdout.write(`No Standards instance selected. Run "standards login".
+`);
+      return;
+    }
+    process.stdout.write(`${profile.name} ${profile.apiUrl}
+`);
+  });
+  program.command("logout").description("Remove a Standards instance from local CLI config").argument("[name]", "instance name, defaults to current").action(async (name) => {
+    await removeProfile(name);
+    process.stdout.write(`${chalk4.green("\u2713")} Standards instance removed.
+`);
+  });
+}
+
+// src/commands/schema.ts
+function registerSchemaCommand(program) {
+  const schema = program.command("schema").description("Inspect schema objects and attributes");
   schema.command("list").description("List all schema objects").action(async (_opts, cmd) => {
-    const client = getClientFromCommand4(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get("/schema/objects");
-    formatOutput(result, getFormat4(cmd));
+    formatOutput(result, getFormat(cmd));
   });
   schema.command("inspect").description("Inspect an object (attributes, types, views)").argument("<object>", "object name or ID").action(async (objectName, _opts, cmd) => {
-    const client = getClientFromCommand4(cmd);
+    const client = getClientFromCommand(cmd);
     const result = await client.get(`/schema/objects/${objectName}`);
-    formatOutput(result, getFormat4(cmd));
+    formatOutput(result, getFormat(cmd));
   });
 }
 
-// src/bin.ts
-var program = new Command();
-program.name("standards").description("CLI to interact with Standards API").version("1.0.0-alpha.1").option("--format <format>", "output format (json, table, csv)", "json").option(
-  "--api-url <url>",
-  "API base URL",
-  process.env.STANDARDS_API_URL ?? "http://localhost:4100"
-).option("--api-key <key>", "API key for authentication", process.env.STANDARDS_API_KEY);
-registerRecordsCommand(program);
-registerSchemaCommand(program);
-registerDocumentsCommand(program);
-registerAuthCommand(program);
-program.hook("preAction", (_thisCommand, _actionCommand) => {
-  const opts = program.opts();
-  if (!opts.apiKey) {
-    console.error(
-      chalk3.red("\u2717 Error: No API key configured. Set STANDARDS_API_KEY or use --api-key")
-    );
-    process.exit(1);
-  }
-});
-program.parseAsync(process.argv).catch((error) => {
-  if (error instanceof ApiClientError) {
-    if (error.statusCode > 0) {
-      console.error(chalk3.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
-    } else {
-      console.error(chalk3.red(`\u2717 Error: ${error.message}`));
+// src/program.ts
+var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help"]);
+function isPublicCommand(actionCommand) {
+  if (PUBLIC_COMMANDS.has(actionCommand.name())) return true;
+  return actionCommand.parent?.name() === "auth" && actionCommand.name() === "help";
+}
+function createProgram() {
+  const program = new Command();
+  program.name("standards").description("CLI to interact with Standards API").version("1.0.0-alpha.3").option("--format <format>", "output format (json, table, csv)", "json").option("--api-url <url>", "API base URL").option("--api-key <key>", "API key for authentication").option("--instance <name>", "Standards instance profile to use");
+  registerRootCommands(program);
+  registerRecordsCommand(program);
+  registerSchemaCommand(program);
+  registerDocumentsCommand(program);
+  registerKeysCommand(program);
+  registerAuthCommand(program);
+  program.hook("preAction", async (_thisCommand, actionCommand) => {
+    const raw = program.opts();
+    const resolved = await resolveCliConfig({
+      apiUrl: raw.apiUrl,
+      apiKey: raw.apiKey,
+      instance: raw.instance
+    });
+    program.setOptionValue("apiUrl", resolved.apiUrl);
+    program.setOptionValue("apiKey", resolved.apiKey);
+    program.setOptionValue("profileName", resolved.profileName);
+    if (!(resolved.apiKey || isPublicCommand(actionCommand))) {
+      console.error(
+        chalk5.red(
+          `\u2717 Error: No Standards instance configured. Run "standards login" or pass --api-key.`
+        )
+      );
+      process.exit(1);
     }
-  } else if (error instanceof Error) {
-    console.error(chalk3.red(`\u2717 Error: ${error.message}`));
-  }
-  process.exit(1);
-});
+  });
+  return program;
+}
+async function runProgram(argv = process.argv) {
+  const program = createProgram();
+  await program.parseAsync(argv).catch((error) => {
+    if (error instanceof ApiClientError) {
+      if (error.statusCode > 0) {
+        console.error(chalk5.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
+      } else {
+        console.error(chalk5.red(`\u2717 Error: ${error.message}`));
+      }
+    } else if (error instanceof Error) {
+      console.error(chalk5.red(`\u2717 Error: ${error.message}`));
+    }
+    process.exit(1);
+  });
+}
+
+// src/bin.ts
+await runProgram();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stndrds/cli",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.3",
   "description": "CLI tool to interact with Standards API",
   "type": "module",
   "bin": {