cli.ts

#!/usr/bin/env node
// CLI entry point — argv normalization, `-h`/`-V` fast paths, dispatch over the command registry,
// and exit-code mapping. Port of `CLIEntry.swift`. Owned by Slice B.
//
// argv normalization mirrors `CLIEntry.effectiveArgv`: no args → the default `usage` command; a
// leading flag (`codexbar --provider claude`) prepends `usage`. Each command parses its own flags
// (and any subcommand token) via `parseArgs`. A thrown `CLIError` maps its `code` to
// `process.exitCode`; any other throw becomes `ExitCode.failure`.

import { CLIError, defaultOutputPrefs, ExitCode, type OutputPrefs } from "./cli/io.ts";
import { findCommand } from "./cli/registry.ts";
import { getVersion, helpForCommand } from "./cli/help.ts";

/** Mirror `CLIEntry.effectiveArgv`: empty → ["usage"]; leading flag → prepend "usage". */
function effectiveArgv(argv: string[]): string[] {
  const first = argv[0];
  if (first == null) return ["usage"];
  if (first.startsWith("-")) return ["usage", ...argv];
  return argv;
}

/** Resolve global OutputPrefs by scanning argv (mirrors `CLIOutputPreferences.from(argv:)`). */
function resolveOutputPrefs(argv: string[]): OutputPrefs {
  const prefs = defaultOutputPrefs();
  for (const arg of argv) {
    switch (arg) {
      case "--json-only":
        prefs.jsonOnly = true;
        break;
      case "--json-output":
        prefs.jsonLogs = true;
        break;
      case "--no-color":
        prefs.useColor = false;
        break;
      case "--pretty":
        prefs.pretty = true;
        break;
      default:
        break;
    }
  }
  return prefs;
}

function kindForCode(code: ExitCode): string {
  switch (code) {
    case ExitCode.parseFailure:
      return "args";
    case ExitCode.providerMissing:
      return "providerMissing";
    case ExitCode.timeout:
      return "timeout";
    default:
      return "runtime";
  }
}

/** Print a CLI-level error, respecting `--json-only` (JSON error payload) vs stderr text. */
function reportError(err: CLIError, prefs: OutputPrefs): void {
  if (prefs.jsonOnly) {
    const payload = {
      provider: "cli",
      account: null,
      version: null,
      source: "cli",
      status: null,
      usage: null,
      credits: null,
      antigravityPlanInfo: null,
      openaiDashboard: null,
      error: { message: err.message, kind: kindForCode(err.code) },
      pace: null,
    };
    process.stdout.write(`${prefs.pretty ? JSON.stringify([payload], null, 2) : JSON.stringify([payload])}\n`);
  } else {
    const message = err.message.startsWith("Error") ? err.message : `Error: ${err.message}`;
    process.stderr.write(`${message}\n`);
  }
}

async function main(): Promise<void> {
  const rawArgv = process.argv.slice(2);
  const argv = effectiveArgv(rawArgv);
  const prefs = resolveOutputPrefs(argv);

  // Fast path: help before building/dispatching commands.
  const helpIndex = argv.findIndex((arg) => arg === "-h" || arg === "--help");
  if (helpIndex >= 0) {
    const commandToken = helpIndex === 0 ? argv[1] : argv[0];
    process.stdout.write(`${helpForCommand(commandToken)}\n`);
    process.exitCode = ExitCode.success;
    return;
  }

  // Fast path: version.
  if (argv.includes("-V") || argv.includes("--version")) {
    process.stdout.write(`CodexBar ${getVersion()}\n`);
    process.exitCode = ExitCode.success;
    return;
  }

  const command = findCommand(argv);
  if (command == null) {
    process.stderr.write(`Error: Unknown command '${argv[0] ?? ""}'.\n`);
    process.exitCode = ExitCode.failure;
    return;
  }

  // Each registry command owns a single top-level token; the remainder (subcommand + flags)
  // is parsed by the command itself.
  const rest = argv.slice(command.path.length);
  try {
    process.exitCode = await command.run(rest, prefs);
  } catch (err) {
    if (err instanceof CLIError) {
      reportError(err, prefs);
      process.exitCode = err.code;
    } else {
      const message = err instanceof Error ? err.message : String(err);
      reportError(new CLIError(message, ExitCode.failure), prefs);
      process.exitCode = ExitCode.failure;
    }
  }
}

await main();