@kirrosh/apitool 0.4.3

package/src/cli/commands/serve.ts

@@ -0,0 +1,22 @@
+import { startServer } from "../../web/server.ts";
+
+export interface ServeOptions {
+  port?: number;
+  host?: string;
+  openapiSpec?: string;
+  testsDir?: string;
+  dbPath?: string;
+  watch?: boolean;
+}
+
+export async function serveCommand(options: ServeOptions): Promise<number> {
+  await startServer({
+    port: options.port,
+    host: options.host,
+    dbPath: options.dbPath,
+    dev: options.watch,
+  });
+
+  // Keep running — Bun.serve keeps the process alive
+  return 0;
+}

package/src/cli/commands/update.ts

@@ -0,0 +1,142 @@
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, unlinkSync, renameSync, copyFileSync, chmodSync } from "fs";
+import { VERSION } from "../index.ts";
+import { isCompiledBinary } from "../runtime.ts";
+
+export interface UpdateCommandOptions {
+  force?: boolean;
+}
+
+export function detectTarget(): { target: string; archive: "tar.gz" | "zip" } {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const os = platform === "win32" ? "win" : platform;
+  const archSuffix = arch === "arm64" ? "arm64" : "x64";
+  const target = `${os}-${archSuffix}`;
+  const archive = platform === "win32" ? "zip" : ("tar.gz" as const);
+
+  return { target, archive };
+}
+
+export function parseVersion(tag: string): string {
+  return tag.replace(/^v/, "");
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+
+export async function updateCommand(options: UpdateCommandOptions): Promise<number> {
+  if (!isCompiledBinary()) {
+    console.log("Running from source — use git pull to update.");
+    return 0;
+  }
+
+  console.log("Checking for updates...");
+
+  // Fetch latest release
+  const res = await fetch("https://api.github.com/repos/kirrosh/apitool/releases/latest", {
+    headers: { "User-Agent": "apitool-updater" },
+  });
+
+  if (!res.ok) {
+    console.error(`Failed to check for updates: HTTP ${res.status}`);
+    return 1;
+  }
+
+  const release = (await res.json()) as { tag_name: string };
+  const latestVersion = parseVersion(release.tag_name);
+  const currentVersion = VERSION;
+
+  if (!options.force && compareVersions(currentVersion, latestVersion) >= 0) {
+    console.log(`Already up to date (v${currentVersion}).`);
+    return 0;
+  }
+
+  console.log(`Updating v${currentVersion} → v${latestVersion}...`);
+
+  const { target, archive } = detectTarget();
+  const assetName = `apitool-${target}.${archive}`;
+  const downloadUrl = `https://github.com/kirrosh/apitool/releases/download/${release.tag_name}/${assetName}`;
+
+  // Download artifact
+  const dlRes = await fetch(downloadUrl);
+  if (!dlRes.ok) {
+    console.error(`Failed to download ${assetName}: HTTP ${dlRes.status}`);
+    return 1;
+  }
+
+  const tempDir = tmpdir();
+  const archivePath = join(tempDir, assetName);
+  const archiveBytes = new Uint8Array(await dlRes.arrayBuffer());
+  await Bun.write(archivePath, archiveBytes);
+
+  // Extract
+  const extractDir = join(tempDir, `apitool-update-${Date.now()}`);
+  const mkdirResult = Bun.spawnSync(["mkdir", "-p", extractDir]);
+  if (mkdirResult.exitCode !== 0) {
+    // Fallback for Windows
+    const { mkdirSync } = await import("fs");
+    mkdirSync(extractDir, { recursive: true });
+  }
+
+  if (archive === "tar.gz") {
+    const tar = Bun.spawnSync(["tar", "-xzf", archivePath, "-C", extractDir]);
+    if (tar.exitCode !== 0) {
+      console.error("Failed to extract archive.");
+      return 1;
+    }
+  } else {
+    // Windows zip — use tar (Windows 10+ includes bsdtar)
+    const tar = Bun.spawnSync(["tar", "-xf", archivePath, "-C", extractDir]);
+    if (tar.exitCode !== 0) {
+      console.error("Failed to extract archive.");
+      return 1;
+    }
+  }
+
+  // Find extracted binary
+  const binaryName = process.platform === "win32" ? "apitool.exe" : "apitool";
+  const newBinary = join(extractDir, binaryName);
+
+  if (!existsSync(newBinary)) {
+    console.error(`Expected binary not found: ${newBinary}`);
+    return 1;
+  }
+
+  // Replace current binary
+  const currentBinary = process.execPath;
+
+  if (process.platform === "win32") {
+    // Windows: can't overwrite running exe — rename current to .old, copy new
+    const oldPath = currentBinary + ".old";
+    try {
+      if (existsSync(oldPath)) unlinkSync(oldPath);
+    } catch { /* ignore */ }
+    renameSync(currentBinary, oldPath);
+    copyFileSync(newBinary, currentBinary);
+  } else {
+    // Unix: rename new over current (atomic on same filesystem, but we copy across)
+    unlinkSync(currentBinary);
+    copyFileSync(newBinary, currentBinary);
+    chmodSync(currentBinary, 0o755);
+  }
+
+  // Cleanup
+  try {
+    unlinkSync(archivePath);
+    unlinkSync(newBinary);
+  } catch { /* best effort */ }
+
+  console.log(`Updated to v${latestVersion}.`);
+  return 0;
+}

package/src/cli/commands/validate.ts

@@ -0,0 +1,18 @@
+import { parse } from "../../core/parser/yaml-parser.ts";
+import { printError, printSuccess } from "../output.ts";
+
+export interface ValidateOptions {
+  path: string;
+}
+
+export async function validateCommand(options: ValidateOptions): Promise<number> {
+  try {
+    const suites = await parse(options.path);
+    const totalSteps = suites.reduce((sum, s) => sum + s.tests.length, 0);
+    printSuccess(`OK: ${suites.length} suite(s), ${totalSteps} test(s) validated successfully`);
+    return 0;
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return 2;
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,500 @@
+#!/usr/bin/env bun
+
+import { runCommand } from "./commands/run.ts";
+import { validateCommand } from "./commands/validate.ts";
+import { serveCommand } from "./commands/serve.ts";
+import { collectionsCommand } from "./commands/collections.ts";
+import { aiGenerateCommand } from "./commands/ai-generate.ts";
+import { mcpCommand } from "./commands/mcp.ts";
+import { initCommand } from "./commands/init.ts";
+import { updateCommand } from "./commands/update.ts";
+import { chatCommand } from "./commands/chat.ts";
+import { envsCommand } from "./commands/envs.ts";
+import { runsCommand } from "./commands/runs.ts";
+import { coverageCommand } from "./commands/coverage.ts";
+import { doctorCommand } from "./commands/doctor.ts";
+import { addApiCommand } from "./commands/add-api.ts";
+import { ciInitCommand } from "./commands/ci-init.ts";
+import { printError } from "./output.ts";
+import { getRuntimeInfo } from "./runtime.ts";
+import { getDb } from "../db/schema.ts";
+import { findCollectionByNameOrId } from "../db/queries.ts";
+import type { ReporterName } from "../core/reporter/types.ts";
+
+export const VERSION = "0.3.0";
+
+export interface ParsedArgs {
+  command: string | undefined;
+  positional: string[];
+  flags: Record<string, string | boolean>;
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  // argv: [bunPath, scriptPath, ...userArgs]
+  const args = argv.slice(2);
+  let command: string | undefined;
+  const positional: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i]!;
+
+    if (arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      if (eqIndex !== -1) {
+        // --flag=value
+        flags[arg.slice(2, eqIndex)] = arg.slice(eqIndex + 1);
+      } else {
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next !== undefined && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      // Short flag: -h, -v
+      flags[arg.slice(1)] = true;
+    } else if (command === undefined) {
+      command = arg;
+    } else {
+      positional.push(arg);
+    }
+
+    i++;
+  }
+
+  return { command, positional, flags };
+}
+
+function printUsage(): void {
+  console.log(`apitool - API Testing Platform
+
+Usage:
+  apitool add-api <name>   Register a new API (collection)
+  apitool run <path>       Run API tests
+  apitool validate <path>  Validate test files without running
+  apitool ai-generate --from <spec> --prompt "..."  Generate tests with AI
+  apitool envs [list|get|set|delete]  Manage environments
+  apitool runs [id]        View test run history
+  apitool coverage --spec <path> --tests <dir>  Analyze API test coverage
+  apitool collections      List test collections
+  apitool serve            Start web dashboard
+  apitool init             Initialize a new apitool project
+  apitool ci init          Generate CI/CD workflow (GitHub Actions, GitLab CI)
+  apitool mcp              Start MCP server (stdio transport for AI agents)
+                           --dir <path>  Set working directory (relative paths resolve here)
+  apitool chat             Start interactive AI chat for API testing
+  apitool doctor           Run diagnostic checks
+  apitool update           Update to latest version
+
+Options for 'add-api':
+  --spec <path-or-url>   OpenAPI spec (extracts base_url from servers[0])
+  --dir <directory>      Base directory (default: ./apis/<name>/)
+  --env key=value        Set environment variables (repeatable)
+
+Options for 'chat':
+  --provider <name>    LLM provider: ollama, openai, anthropic, custom (default: ollama)
+  --model <name>       Model name (default: provider-specific)
+  --api-key <key>      API key (or set APITOOL_AI_KEY env var)
+  --base-url <url>     Provider base URL override
+  --safe               Only allow running GET tests (read-only mode)
+
+Options for 'envs':
+  envs                 List all environments
+  envs get <name>      Show variables in an environment
+  envs set <name> K=V  Set variables (multiple KEY=VALUE pairs)
+  envs delete <name>   Delete an environment
+  envs import <name> <file>  Import environment from YAML file
+  envs export <name>   Export environment as YAML to stdout
+  --api <name>         Scope operation to a specific API collection
+
+Options for 'runs':
+  runs                 List recent test runs
+  runs <id>            Show run details with step results
+  --limit <n>          Number of runs to show (default: 20)
+
+Options for 'coverage':
+  --api <name>         Use API collection (auto-resolves spec and tests dir)
+  --spec <path>        Path to OpenAPI spec (required unless --api used)
+  --tests <dir>        Path to test files directory (required unless --api used)
+
+Options for 'run':
+  --api <name>         Use API collection (resolves test path automatically)
+  --env <name>         Use environment file (.env.<name>.yaml)
+  --report <format>    Output format: console, json, junit (default: console)
+  --timeout <ms>       Override request timeout
+  --bail               Stop on first suite failure
+  --no-db              Do not save results to apitool.db
+  --db <path>          Path to SQLite database file (default: apitool.db)
+  --auth-token <token> Auth token injected as {{auth_token}} variable
+  --safe               Run only GET tests (read-only, safe mode)
+  --tag <tag>          Filter suites by tag (repeatable, comma-separated, OR logic)
+
+Options for 'ai-generate':
+  --api <name>         Use API collection (auto-resolves spec and output dir)
+  --from <spec>        Path to OpenAPI spec (required unless --api used)
+  --prompt <text>      Test scenario description (required)
+  --provider <name>    LLM provider: ollama, openai, anthropic, custom (default: ollama)
+  --model <name>       Model name (default: provider-specific)
+  --api-key <key>      API key (or set APITOOL_AI_KEY env var)
+  --base-url <url>     Provider base URL override
+  --output <dir>       Output directory (default: ./generated/ai/)
+
+Options for 'serve':
+  --port <port>        Server port (default: 8080)
+  --host <host>        Server host (default: 0.0.0.0)
+  --openapi <spec>     Path to OpenAPI spec for Explorer
+  --db <path>          Path to SQLite database file (default: apitool.db)
+  --watch              Enable dev mode with hot reload (auto-refresh browser on file changes)
+
+Options for 'ci init':
+  --github             Generate GitHub Actions workflow
+  --gitlab             Generate GitLab CI config
+  --dir <path>         Project root directory (default: current directory)
+  --force              Overwrite existing CI config
+
+General:
+  --help, -h           Show this help
+  --version, -v        Show version`);
+}
+
+const VALID_REPORTERS = new Set<string>(["console", "json", "junit"]);
+
+async function main(): Promise<number> {
+  const { command, positional, flags } = parseArgs(process.argv);
+
+  // Help
+  if (command === "help" || command === "--help" || flags["help"] === true || flags["h"] === true) {
+    printUsage();
+    return 0;
+  }
+
+  // Version
+  if (command === "--version" || flags["version"] === true || flags["v"] === true) {
+    console.log(`apitool ${VERSION} (${getRuntimeInfo()})`);
+    return 0;
+  }
+
+  if (!command) {
+    printUsage();
+    return 0;
+  }
+
+  switch (command) {
+    case "add-api": {
+      const name = positional[0];
+      if (!name) {
+        printError("Missing name argument. Usage: apitool add-api <name> [--spec <path>] [--dir <dir>]");
+        return 2;
+      }
+
+      // Collect all --env flags (parseArgs only stores last one, so re-parse)
+      const envValues: string[] = [];
+      const rawArgs = process.argv.slice(2);
+      for (let i = 0; i < rawArgs.length; i++) {
+        if (rawArgs[i] === "--env" && rawArgs[i + 1] && rawArgs[i + 1]!.includes("=")) {
+          envValues.push(rawArgs[i + 1]!);
+          i++;
+        } else if (rawArgs[i]?.startsWith("--env=") && rawArgs[i]!.slice(6).includes("=")) {
+          envValues.push(rawArgs[i]!.slice(6));
+        }
+      }
+
+      return addApiCommand({
+        name,
+        spec: typeof flags["spec"] === "string" ? flags["spec"] : undefined,
+        dir: typeof flags["dir"] === "string" ? flags["dir"] : undefined,
+        envPairs: envValues.length > 0 ? envValues : undefined,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+      });
+    }
+
+    case "run": {
+      let path = positional[0];
+      const apiFlag = typeof flags["api"] === "string" ? flags["api"] : undefined;
+      if (!path && apiFlag) {
+        try {
+          getDb(typeof flags["db"] === "string" ? flags["db"] : undefined);
+          const col = findCollectionByNameOrId(apiFlag);
+          if (!col) { printError(`API '${apiFlag}' not found`); return 1; }
+          path = col.test_path;
+        } catch (err) {
+          printError(`Failed to resolve --api: ${(err as Error).message}`);
+          return 2;
+        }
+      }
+      if (!path) {
+        printError("Missing path argument. Usage: apitool run <path> or apitool run --api <name>");
+        return 2;
+      }
+
+      const report = (flags["report"] as string) ?? "console";
+      if (!VALID_REPORTERS.has(report)) {
+        printError(`Unknown reporter: ${report}. Available: console, json, junit`);
+        return 2;
+      }
+
+      const timeoutRaw = flags["timeout"];
+      let timeout: number | undefined;
+      if (typeof timeoutRaw === "string") {
+        timeout = parseInt(timeoutRaw, 10);
+        if (isNaN(timeout) || timeout <= 0) {
+          printError(`Invalid timeout value: ${timeoutRaw}`);
+          return 2;
+        }
+      }
+
+      // Collect all --tag flags (parseArgs only stores last one, so re-parse)
+      const tagValues: string[] = [];
+      const rawRunArgs = process.argv.slice(2);
+      for (let i = 0; i < rawRunArgs.length; i++) {
+        if (rawRunArgs[i] === "--tag" && rawRunArgs[i + 1]) {
+          tagValues.push(rawRunArgs[i + 1]!);
+          i++;
+        } else if (rawRunArgs[i]?.startsWith("--tag=")) {
+          tagValues.push(rawRunArgs[i]!.slice("--tag=".length));
+        }
+      }
+      // Support comma-separated: --tag smoke,crud → ["smoke", "crud"]
+      const tags = tagValues.flatMap(v => v.split(",")).filter(Boolean);
+
+      return runCommand({
+        path,
+        env: typeof flags["env"] === "string" ? flags["env"] : undefined,
+        report: report as ReporterName,
+        timeout,
+        bail: flags["bail"] === true,
+        noDb: flags["no-db"] === true,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+        authToken: typeof flags["auth-token"] === "string" ? flags["auth-token"] : undefined,
+        safe: flags["safe"] === true,
+        tag: tags.length > 0 ? tags : undefined,
+      });
+    }
+
+    case "validate": {
+      const path = positional[0];
+      if (!path) {
+        printError("Missing path argument. Usage: apitool validate <path>");
+        return 2;
+      }
+
+      return validateCommand({ path });
+    }
+
+    case "ai-generate": {
+      let from = flags["from"] as string | undefined;
+      let output = typeof flags["output"] === "string" ? flags["output"] : undefined;
+      const aiGenApiFlag = typeof flags["api"] === "string" ? flags["api"] : undefined;
+
+      // Resolve --api to spec and output dir from collection
+      if (aiGenApiFlag) {
+        try {
+          getDb(typeof flags["db"] === "string" ? flags["db"] : undefined);
+          const col = findCollectionByNameOrId(aiGenApiFlag);
+          if (!col) { printError(`API '${aiGenApiFlag}' not found`); return 1; }
+          if (!from && col.openapi_spec) from = col.openapi_spec;
+          if (!output && col.test_path) output = col.test_path;
+        } catch (err) {
+          printError(`Failed to resolve --api: ${(err as Error).message}`);
+          return 2;
+        }
+      }
+
+      if (typeof from !== "string") {
+        printError("Missing --from <spec>. Usage: apitool ai-generate --from <spec> --prompt \"...\"");
+        return 2;
+      }
+      const prompt = flags["prompt"];
+      if (typeof prompt !== "string") {
+        printError("Missing --prompt <text>. Usage: apitool ai-generate --from <spec> --prompt \"...\"");
+        return 2;
+      }
+      return aiGenerateCommand({
+        from,
+        prompt,
+        provider: typeof flags["provider"] === "string" ? flags["provider"] : "ollama",
+        model: typeof flags["model"] === "string" ? flags["model"] : undefined,
+        apiKey: typeof flags["api-key"] === "string" ? flags["api-key"] : undefined,
+        baseUrl: typeof flags["base-url"] === "string" ? flags["base-url"] : undefined,
+        output,
+      });
+    }
+
+    case "collections": {
+      return collectionsCommand(
+        typeof flags["db"] === "string" ? flags["db"] : undefined,
+      );
+    }
+
+    case "serve": {
+      const portRaw = flags["port"];
+      let port: number | undefined;
+      if (typeof portRaw === "string") {
+        port = parseInt(portRaw, 10);
+        if (isNaN(port) || port <= 0) {
+          printError(`Invalid port value: ${portRaw}`);
+          return 2;
+        }
+      }
+      return serveCommand({
+        port,
+        host: typeof flags["host"] === "string" ? flags["host"] : undefined,
+        openapiSpec: typeof flags["openapi"] === "string" ? flags["openapi"] : undefined,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+        watch: flags["watch"] === true,
+      });
+    }
+
+    case "init": {
+      return initCommand({
+        force: flags["force"] === true,
+      });
+    }
+
+    case "mcp": {
+      return mcpCommand({
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+        dir: typeof flags["dir"] === "string" ? flags["dir"] : undefined,
+      });
+    }
+
+    case "chat": {
+      return chatCommand({
+        provider: typeof flags["provider"] === "string" ? flags["provider"] : undefined,
+        model: typeof flags["model"] === "string" ? flags["model"] : undefined,
+        apiKey: typeof flags["api-key"] === "string" ? flags["api-key"] : undefined,
+        baseUrl: typeof flags["base-url"] === "string" ? flags["base-url"] : undefined,
+        safe: flags["safe"] === true,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+      });
+    }
+
+    case "update": {
+      return updateCommand({ force: flags["force"] === true });
+    }
+
+    case "envs": {
+      const sub = positional[0] as string | undefined;
+      const validActions = ["get", "set", "delete", "import", "export"] as const;
+      const action = validActions.includes(sub as any) ? (sub as typeof validActions[number]) : "list";
+      const name = action === "list" ? undefined : positional[1];
+      const pairs = action === "set" ? positional.slice(2) : undefined;
+      const file = action === "import" ? positional[2] : undefined;
+
+      return envsCommand({
+        action,
+        name,
+        pairs,
+        file,
+        api: typeof flags["api"] === "string" ? flags["api"] : undefined,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+      });
+    }
+
+    case "runs": {
+      const idRaw = positional[0];
+      let runId: number | undefined;
+      if (idRaw) {
+        runId = parseInt(idRaw, 10);
+        if (isNaN(runId)) {
+          printError(`Invalid run ID: ${idRaw}`);
+          return 2;
+        }
+      }
+
+      const limitRaw = flags["limit"];
+      let limit: number | undefined;
+      if (typeof limitRaw === "string") {
+        limit = parseInt(limitRaw, 10);
+        if (isNaN(limit) || limit <= 0) {
+          printError(`Invalid limit value: ${limitRaw}`);
+          return 2;
+        }
+      }
+
+      return runsCommand({
+        runId,
+        limit,
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+      });
+    }
+
+    case "ci": {
+      const ciSub = positional[0];
+      if (ciSub !== "init") {
+        printError("Usage: apitool ci init [--github|--gitlab] [--force]");
+        return 2;
+      }
+      let platform: "github" | "gitlab" | undefined;
+      if (flags["github"] === true) platform = "github";
+      else if (flags["gitlab"] === true) platform = "gitlab";
+      return ciInitCommand({
+        platform,
+        force: flags["force"] === true,
+        dir: typeof flags["dir"] === "string" ? flags["dir"] : undefined,
+      });
+    }
+
+    case "doctor": {
+      return doctorCommand({
+        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
+      });
+    }
+
+    case "coverage": {
+      let spec = flags["spec"] as string | undefined;
+      let tests = flags["tests"] as string | undefined;
+      const coverageApiFlag = typeof flags["api"] === "string" ? flags["api"] : undefined;
+
+      if (coverageApiFlag) {
+        try {
+          getDb(typeof flags["db"] === "string" ? flags["db"] : undefined);
+          const col = findCollectionByNameOrId(coverageApiFlag);
+          if (!col) { printError(`API '${coverageApiFlag}' not found`); return 1; }
+          if (!spec && col.openapi_spec) spec = col.openapi_spec;
+          if (!tests && col.test_path) tests = col.test_path;
+        } catch (err) {
+          printError(`Failed to resolve --api: ${(err as Error).message}`);
+          return 2;
+        }
+      }
+
+      if (typeof spec !== "string") {
+        printError("Missing --spec <path>. Usage: apitool coverage --spec <path> --tests <dir>");
+        return 2;
+      }
+      if (typeof tests !== "string") {
+        printError("Missing --tests <dir>. Usage: apitool coverage --spec <path> --tests <dir>");
+        return 2;
+      }
+      return coverageCommand({ spec, tests });
+    }
+
+    default: {
+      printError(`Unknown command: ${command}`);
+      printUsage();
+      return 2;
+    }
+  }
+}
+
+// Only run when executed directly, not when imported
+const scriptPath = process.argv[1]?.replaceAll("\\", "/") ?? "";
+const metaFile = import.meta.filename?.replaceAll("\\", "/") ?? "";
+const isMain = scriptPath === metaFile
+  || scriptPath.endsWith("cli/index.ts")
+  || import.meta.main === true;
+if (isMain) {
+  try {
+    const code = await main();
+    process.exitCode = code;
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exitCode = 2;
+  }
+}