@bugbug-io/cli 13.39.1

package/dist/index.js

@@ -0,0 +1,1442 @@
+#!/usr/bin/env node
+import {
+  render
+} from "./chunk-UZVYEMEZ.js";
+import {
+  BaseSuiteRunDetails,
+  BaseTestRunDetails,
+  DEFAULT_MCP_URL,
+  EXIT_GENERAL_ERROR,
+  EXIT_USAGE_ERROR,
+  MCP_SERVER_PACKAGE,
+  PLUGIN_PACKAGE_NAME,
+  PLUGIN_REPO_SOURCE,
+  addBreadcrumb,
+  analytics,
+  captureException,
+  closeSentry,
+  defaultJunitReportPath,
+  detectFormat,
+  emitError,
+  exitCodeForStatus,
+  exitWith,
+  exportProject,
+  exportTest,
+  formatErrorMessage,
+  formatInlineRunReport,
+  getCliConfig,
+  getSuite,
+  getSuiteRun,
+  getSuiteRunJunitReport,
+  getTest,
+  getTestRun,
+  getTestRunJunitReport,
+  getTestRunLogs,
+  getVariablesMap,
+  getVersion,
+  importProject,
+  importTest,
+  initProject,
+  initSentry,
+  listProfiles,
+  listSuites,
+  listTests,
+  login,
+  logout,
+  resolveOutputMode,
+  runClientCommand,
+  runSuite,
+  runTest,
+  setSentryTag,
+  showError,
+  startSentrySpan,
+  stopSuiteRun,
+  stopTestRun,
+  validateReporterOptions,
+  waitForSuiteRun,
+  waitForTestRun,
+  writeReportXml
+} from "./chunk-NTNHB6R6.js";
+
+// src/instrument.ts
+initSentry({ telemetryEnabled: getCliConfig().telemetryEnabled, env: process.env });
+
+// src/index.ts
+import { Command, CommanderError } from "commander";
+
+// src/utils/output.ts
+var printJson = (value) => {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+};
+
+// src/features/auth/auth.command.ts
+var registerLoginCommand = (program2, commandName = "login") => program2.command(commandName).description("Log in to BugBug and store a user token in the global config.").action(async () => {
+  const mode = resolveOutputMode();
+  try {
+    const result = await login();
+    if (mode === "json") {
+      printJson(result);
+    } else {
+      process.stdout.write(`Logged in. Token saved to "${result.credentialsFile}"
+`);
+    }
+    const shouldBackfillSessionStart = !analytics.get().isEnabled;
+    analytics.refreshWithToken(result.token);
+    if (shouldBackfillSessionStart) {
+      analytics.trackEvent("cli_session_started");
+    }
+    analytics.trackEvent("cli_logged_in", { success: true, outputMode: mode });
+  } catch (err) {
+    analytics.trackEvent("cli_logged_in", { success: false, outputMode: mode });
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerLogoutCommand = (program2, commandName = "logout") => program2.command(commandName).description("Log out of BugBug and clear the user token and current project.").action(() => {
+  const mode = resolveOutputMode();
+  try {
+    const result = logout();
+    if (mode === "json") {
+      printJson(result);
+    } else if (result.cleared) {
+      process.stdout.write("Logged out.\n");
+    } else {
+      process.stdout.write("Already logged out.\n");
+    }
+    analytics.trackEvent("cli_logged_out", { success: true, outputMode: mode });
+  } catch (err) {
+    analytics.trackEvent("cli_logged_out", { success: false, outputMode: mode });
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerAuthCommands = (program2) => {
+  registerLoginCommand(program2);
+  registerLogoutCommand(program2);
+};
+
+// src/features/install/install.service.ts
+import { homedir } from "os";
+
+// ../core/dist/install/clients.js
+import { join } from "path";
+
+// ../core/dist/install/skills.js
+import { existsSync } from "fs";
+var SKILLS_AGENT = {
+  windsurf: "windsurf",
+  cursor: "cursor",
+  vscode: "github-copilot"
+};
+var skillsAddArgv = (agent) => [
+  "npx",
+  "skills",
+  "add",
+  "bugbug-io/agent-plugin/skills",
+  "--agent",
+  agent,
+  "--global",
+  "--copy",
+  "--yes"
+];
+var installSkillsViaCli = async (clientId, finalDir, dryRun = false, options = {}) => {
+  const existedBefore = existsSync(finalDir);
+  if (dryRun)
+    return existedBefore ? "updated" : "created";
+  const agent = SKILLS_AGENT[clientId];
+  if (!agent) {
+    throw new Error(`BugBug skills are not supported for ${clientId}.`);
+  }
+  const argv = skillsAddArgv(agent);
+  const { ok, code } = runClientCommand(argv, options);
+  if (!ok) {
+    throw new Error(`Failed to install BugBug skills. (exit ${code}).`);
+  }
+  return existedBefore ? "updated" : "created";
+};
+
+// ../core/dist/install/writers.js
+import { existsSync as existsSync3 } from "fs";
+
+// ../core/dist/install/jsonConfig.js
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var readJsonObject = (path) => {
+  if (!existsSync2(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+var writeJsonObject = (path, value) => {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+};
+var getObject = (parent, key) => {
+  const existing = parent[key];
+  return existing && typeof existing === "object" ? existing : {};
+};
+var sameEntry = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+// ../core/dist/install/writers.js
+var MCP_SERVER_KEY = "bugbug";
+var buildMcpEntry = (shape, endpoint) => {
+  if (endpoint.transport === "stdio") {
+    const env = {};
+    if (endpoint.token)
+      env.API_TOKEN = endpoint.token;
+    if (endpoint.apiUrl)
+      env.BUGBUG_API_URL = endpoint.apiUrl;
+    if (endpoint.publicBaseUrl)
+      env.MCP_PUBLIC_BASE_URL = endpoint.publicBaseUrl;
+    const entry2 = {
+      command: "npx",
+      args: ["-y", MCP_SERVER_PACKAGE]
+    };
+    if (Object.keys(env).length > 0)
+      entry2.env = env;
+    return entry2;
+  }
+  const entry = { url: endpoint.url };
+  if (!shape.omitsHttpType)
+    entry.type = "http";
+  if (shape.oauthResource)
+    entry.oauth_resource = endpoint.url;
+  if (endpoint.token) {
+    entry.headers = { Authorization: `Bearer ${endpoint.token}` };
+  }
+  return entry;
+};
+var mergeMcpEntry = (existing, built) => {
+  const previous = existing && typeof existing === "object" ? { ...existing } : {};
+  if (!("headers" in built))
+    delete previous.headers;
+  return { ...previous, ...built };
+};
+var writeMcpConfig = (path, shape, endpoint, dryRun = false) => {
+  const existed = existsSync3(path);
+  const config = readJsonObject(path);
+  const servers = getObject(config, shape.serversKey);
+  const entry = mergeMcpEntry(servers[MCP_SERVER_KEY], buildMcpEntry(shape, endpoint));
+  if (existed && sameEntry(servers[MCP_SERVER_KEY], entry)) {
+    return "skipped";
+  }
+  if (dryRun)
+    return existed ? "updated" : "created";
+  servers[MCP_SERVER_KEY] = entry;
+  config[shape.serversKey] = servers;
+  writeJsonObject(path, config);
+  return existed ? "updated" : "created";
+};
+
+// ../core/dist/install/manualPlugin.js
+var RANK = {
+  skipped: 0,
+  executed: 1,
+  unsupported: 2,
+  updated: 3,
+  created: 4
+};
+var strongest = (a, b) => RANK[a] >= RANK[b] ? a : b;
+var manualPlugin = async (client, ctx, { shape, mcpPath, skillsClient, skillsDir }) => {
+  const mcpAction = writeMcpConfig(mcpPath, shape, ctx.endpoint, ctx.dryRun);
+  let skillsAction;
+  try {
+    skillsAction = await installSkillsViaCli(skillsClient, skillsDir, ctx.dryRun, ctx.runnerOptions);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      client,
+      path: `${mcpPath} (mcp: ${mcpAction})`,
+      action: "unsupported",
+      message: `Wrote MCP config but could not install skills: ${message}`
+    };
+  }
+  return {
+    client,
+    path: `${mcpPath}, ${skillsDir}`,
+    action: strongest(mcpAction, skillsAction)
+  };
+};
+
+// ../core/dist/install/clients.js
+var windsurfMcpPath = (ctx) => join(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+var windsurfSkillsDir = (ctx) => join(ctx.home, ".codeium", "windsurf", "skills");
+var CLIENTS = {
+  cursor: {
+    id: "cursor",
+    displayName: "Cursor",
+    cliName: "cursor",
+    detectDir: ".cursor",
+    // The CLI owns Cursor's skills layout, avoiding the stale, renamed skills a
+    // manual copy left behind.
+    pluginsTarget: "cursor"
+  },
+  claude: {
+    id: "claude",
+    displayName: "Claude Code",
+    cliName: "claude",
+    detectDir: ".claude",
+    pluginsTarget: "claude-code"
+  },
+  vscode: {
+    id: "vscode",
+    displayName: "VS Code",
+    cliName: "code",
+    detectDir: ".vscode",
+    // Registers the staged bundle in VS Code's user-level `chat.pluginLocations`.
+    // Agent plugins are Preview there, so `chat.plugins.enabled` may be needed.
+    pluginsTarget: "vscode"
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex",
+    cliName: "codex",
+    detectDir: ".codex",
+    pluginsTarget: "codex",
+    postInstallAuth: {
+      command: "codex",
+      resetArgs: ["mcp", "logout", "bugbug"],
+      args: ["mcp", "login", "bugbug"]
+    }
+  },
+  copilot: {
+    id: "copilot",
+    displayName: "GitHub Copilot CLI",
+    cliName: "copilot",
+    detectDir: ".copilot",
+    // Registers the source as a marketplace then installs `plugin@marketplace`,
+    // avoiding Copilot's deprecated direct local-path installs.
+    pluginsTarget: "github-copilot"
+  },
+  windsurf: {
+    id: "windsurf",
+    displayName: "Windsurf",
+    detectDir: join(".codeium", "windsurf"),
+    // The one client the `plugins` CLI has no target for, so it keeps the
+    // hand-written install: the MCP server written into its own config plus the
+    // BugBug skills installed via the `skills` CLI. This is also the only path
+    // that can carry a bearer token, since delegated clients authenticate
+    // through their own MCP OAuth flow.
+    installPlugin: (ctx) => manualPlugin("windsurf", ctx, {
+      shape: { serversKey: "mcpServers" },
+      mcpPath: windsurfMcpPath(ctx),
+      skillsClient: "windsurf",
+      skillsDir: windsurfSkillsDir(ctx)
+    })
+  }
+};
+
+// ../core/dist/install/pluginsCli.js
+var PLUGINS_CLI_ENV = {
+  DISABLE_TELEMETRY: "1",
+  DO_NOT_TRACK: "1"
+};
+var buildPluginsCliArgv = (target, source) => [
+  "npx",
+  "-y",
+  "plugins",
+  "add",
+  source,
+  "--target",
+  target,
+  "--yes"
+];
+var runPluginsCli = ({ target, source, dryRun = false, runnerOptions }) => {
+  const argv = buildPluginsCliArgv(target, source);
+  const command = argv.join(" ");
+  if (dryRun)
+    return { action: "executed", command };
+  const { ok, code } = runClientCommand(argv, {
+    ...runnerOptions,
+    env: { ...PLUGINS_CLI_ENV }
+  });
+  if (!ok) {
+    return {
+      action: "unsupported",
+      command,
+      message: `\`${command}\` failed (exit ${code}).`
+    };
+  }
+  return { action: "executed", command };
+};
+
+// ../core/dist/install/installPlugin.js
+var runPostInstallAuth = (ctx, auth) => {
+  const resetCommand = auth.resetArgs ? [auth.command, ...auth.resetArgs].join(" ") : void 0;
+  const argv = [auth.command, ...auth.args];
+  const command = argv.join(" ");
+  const fullCommand = resetCommand ? `${resetCommand} && ${command}` : command;
+  if (ctx.dryRun)
+    return { command: fullCommand };
+  if (auth.resetArgs) {
+    runClientCommand([auth.command, ...auth.resetArgs], { ...ctx.runnerOptions, stdio: "inherit" });
+  }
+  const { ok, code } = runClientCommand(argv, { ...ctx.runnerOptions, stdio: "inherit" });
+  if (!ok) {
+    return { command: fullCommand, message: `\`${command}\` failed (exit ${code}).` };
+  }
+  return { command: fullCommand };
+};
+var installPlugin = (client, ctx) => {
+  const definition = CLIENTS[client];
+  if (definition.pluginsTarget) {
+    const ref = ctx.pluginRef;
+    const source = ref?.kind === "local" ? ref.value : PLUGIN_REPO_SOURCE;
+    const { action, command, message } = runPluginsCli({
+      target: definition.pluginsTarget,
+      source,
+      dryRun: ctx.dryRun,
+      runnerOptions: ctx.runnerOptions
+    });
+    if (!definition.postInstallAuth || action !== "executed") {
+      return { client, path: command, action, message };
+    }
+    const login2 = runPostInstallAuth(ctx, definition.postInstallAuth);
+    return {
+      client,
+      path: `${command} && ${login2.command}`,
+      action,
+      message: [message, login2.message].filter(Boolean).join(" ") || void 0
+    };
+  }
+  if (!definition.installPlugin) {
+    throw new Error(`Client ${client} has neither a plugins target nor an installer.`);
+  }
+  return definition.installPlugin(ctx);
+};
+
+// ../core/dist/install/pluginRef.js
+var PLUGIN_PACKAGE = PLUGIN_PACKAGE_NAME;
+var resolvePluginRef = () => ({ kind: "package", value: PLUGIN_PACKAGE });
+
+// src/utils/toolbox.ts
+var padRight = (value, width) => {
+  if (value.length >= width) return value;
+  return value + " ".repeat(width - value.length);
+};
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+var stripTrailingSlash = (value) => value.replace(/\/+$/, "");
+
+// src/features/install/install.service.ts
+var userHome = () => homedir();
+var resolveEndpoint = ({
+  transport,
+  env = process.env,
+  token
+}) => {
+  const apiUrl = env.BUGBUG_API_URL?.trim() || void 0;
+  const publicBaseUrl = env.MCP_PUBLIC_BASE_URL?.trim() || void 0;
+  const url = publicBaseUrl ? `${stripTrailingSlash(publicBaseUrl)}/mcp` : DEFAULT_MCP_URL;
+  return { transport, url, apiUrl, publicBaseUrl, token };
+};
+var resolveTargetClients = (opts) => {
+  if (opts.client) return [opts.client];
+  throw new Error("Agent is required. Pass --agent=<name>.");
+};
+var install = async (opts) => {
+  const home = opts.home ?? userHome();
+  const token = opts.token ?? getCliConfig().token;
+  const dryRun = opts.dryRun ?? false;
+  const clients = resolveTargetClients({
+    client: opts.client,
+    home,
+    env: opts.env,
+    isCliAvailable: opts.isCliAvailable
+  });
+  const pluginRef = resolvePluginRef();
+  const endpoint = resolveEndpoint({ transport: "http", env: opts.env, token });
+  return Promise.all(
+    clients.map(
+      (client) => installPlugin(client, {
+        home,
+        dryRun,
+        runnerOptions: opts.runnerOptions,
+        pluginRef,
+        endpoint
+      })
+    )
+  );
+};
+
+// ../core/dist/install/install.types.js
+var CLIENT_IDS = ["cursor", "claude", "vscode", "codex", "windsurf", "copilot"];
+var isKnownClient = (value) => CLIENT_IDS.includes(value);
+
+// src/features/install/install.utils.ts
+var AGENT_LIST = CLIENT_IDS.join(", ");
+var validateAgent = (value) => {
+  if (isKnownClient(value)) return value;
+  const mode = resolveOutputMode();
+  emitError(mode === "json" ? "json" : "plain", {
+    error: `Unknown agent "${value}". Supported agents: ${AGENT_LIST}.`
+  });
+  return exitWith(EXIT_USAGE_ERROR);
+};
+var describeResult = (result) => {
+  const name = CLIENTS[result.client].displayName;
+  switch (result.action) {
+    case "created":
+      return `\u2713 ${name}: created ${result.path}`;
+    case "updated":
+      return `\u2713 ${name}: updated ${result.path}`;
+    case "executed":
+      return `\u2713 ${name}: installed via CLI`;
+    case "skipped":
+      return `\u2022 ${name}: already configured (${result.path})`;
+    case "unsupported":
+      return `\u2013 ${name}: ${result.message ?? "not supported"}`;
+    default:
+      return `${name}: ${result.action}`;
+  }
+};
+
+// src/features/install/install.command.ts
+var reportResults = (mode, results, dryRun) => {
+  if (mode === "json") {
+    printJson({ dryRun, results });
+    return;
+  }
+  if (dryRun) {
+    process.stdout.write("Dry run \u2014 no files were written.\n");
+  }
+  if (results.length === 0) {
+    process.stdout.write("No install results.\n");
+    return;
+  }
+  for (const result of results) {
+    process.stdout.write(`${describeResult(result)}
+`);
+  }
+};
+var runInstall = async (opts) => {
+  const mode = resolveOutputMode();
+  const dryRun = Boolean(opts.dryRun);
+  try {
+    if (!opts.agent) {
+      throw new Error(`Agent is required. Pass --agent=<${AGENT_LIST}>.`);
+    }
+    const results = await install({ client: opts.agent, dryRun });
+    reportResults(mode, results, dryRun);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+};
+var addCommonInstallOptions = (command) => command.option("--agent <agent>", `Target a single agent: ${AGENT_LIST}`, validateAgent).option("--dry-run", "Show what would be installed without writing any files");
+var registerPluginCommand = (program2, commandName = "plugin") => addCommonInstallOptions(program2.command(commandName)).description("Install the BugBug plugin (skills + MCP) into one AI client.").action((opts) => runInstall(opts));
+var registerMcpAlias = (program2, commandName = "mcp") => addCommonInstallOptions(program2.command(commandName, { hidden: true })).description("Alias for `bugbug plugin`.").action((opts) => runInstall(opts));
+var registerInstallCommands = (program2) => {
+  registerPluginCommand(program2);
+  registerMcpAlias(program2);
+};
+
+// src/utils/render.ts
+var renderOutput = async (mode, value, formatters) => {
+  if (mode === "json") {
+    printJson(formatters.toJson(value));
+    return;
+  }
+  process.stdout.write(`${formatters.toPlain(value)}
+`);
+};
+
+// src/utils/table.ts
+var renderTable = (rows, columns, options = {}) => {
+  if (rows.length === 0) {
+    return options.emptyMessage ?? "No results.";
+  }
+  const cells = rows.map((row) => columns.map((col) => col.get(row) ?? ""));
+  const widths = columns.map((col, i) => {
+    const dataMax = cells.reduce((max, row) => Math.max(max, row[i]?.length ?? 0), 0);
+    const headerMax = col.header.length;
+    return Math.max(col.width ?? 0, headerMax, dataMax);
+  });
+  const formatRow = (values) => values.map((value, i) => padRight(value, widths[i])).join("  ").trimEnd();
+  const lines = [];
+  lines.push(formatRow(columns.map((c) => c.header.toUpperCase())));
+  lines.push(formatRow(widths.map((w) => "\u2500".repeat(w))));
+  for (const row of cells) {
+    lines.push(formatRow(row));
+  }
+  return lines.join("\n");
+};
+
+// src/features/profiles/profiles.formatters.tsx
+var profilesListOutputFormatters = {
+  toPlain(profiles) {
+    return renderTable(
+      profiles,
+      [
+        { header: "Id", get: (p) => p.id },
+        { header: "Name", get: (p) => p.name },
+        { header: "Default", get: (p) => p.isDefault ? "yes" : "" }
+      ],
+      { emptyMessage: "No profiles found." }
+    );
+  },
+  toJson(profiles) {
+    return profiles;
+  }
+};
+
+// src/features/profiles/profiles.command.ts
+var registerProfilesListCommand = (parent, commandName = "list") => parent.command(commandName).description("List all available profiles").action(async function() {
+  const mode = resolveOutputMode();
+  try {
+    const data = await listProfiles();
+    await renderOutput(mode, data, profilesListOutputFormatters);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerProfilesCommand = (program2) => {
+  const profiles = program2.command("profiles").description("Profile commands");
+  registerProfilesListCommand(profiles, "list");
+  return profiles;
+};
+
+// src/features/project/project.command.ts
+var registerProjectInitCommand = (parent, commandName = "init") => parent.command(commandName).description("Initialize a new BugBug project in the current directory.").action(async () => {
+  const mode = resolveOutputMode();
+  const { token, projectId } = getCliConfig();
+  const trimmedToken = token?.trim();
+  const trimmedProjectId = projectId?.trim();
+  if (!trimmedToken || !trimmedProjectId) {
+    emitError(mode, {
+      error: "init requires --token and --project-id in non-interactive mode."
+    });
+    exitWith(EXIT_GENERAL_ERROR);
+    return;
+  }
+  try {
+    const result = await initProject(trimmedToken, trimmedProjectId);
+    process.stdout.write(`Project initialized at "${result.configFile}"
+`);
+    process.stdout.write(`Token saved to "${result.credentialsFile}"
+`);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerProjectExportCommand = (parent, commandName = "export") => parent.command(commandName).description("Export project data as a ZIP archive").option(
+  "-o, --output <file>",
+  "Output file path (defaults to bugbug-project-export-<timestamp>.zip)"
+).action(async function(opts) {
+  const mode = resolveOutputMode();
+  try {
+    const result = await exportProject(opts.output);
+    if (mode === "json") {
+      printJson(result);
+    } else {
+      process.stdout.write(`Exported project to ${result.outPath} (${result.size} bytes)
+`);
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerProjectImportCommand = (parent, commandName = "import") => parent.command(`${commandName} <file>`).description("Import a project from a ZIP archive").action(async function(file) {
+  const mode = resolveOutputMode();
+  try {
+    if (mode === "plain") {
+      process.stdout.write(`Importing project from ${file}...
+`);
+    }
+    const result = await importProject(file);
+    if (mode === "json") {
+      printJson(result);
+    } else {
+      process.stdout.write(
+        `Project import started from ${result.path} (${result.size} bytes)
+`
+      );
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerProjectCommand = (program2) => {
+  const project = program2.command("project").description("Project commands");
+  registerProjectInitCommand(project, "init");
+  registerProjectExportCommand(project, "export");
+  registerProjectImportCommand(project, "import");
+  return project;
+};
+
+// src/utils/existingRunCommand.ts
+var getExistingRunResultAction = async (runId, opts, adapter) => {
+  const mode = resolveOutputMode();
+  try {
+    if (opts.reporter === "junit") {
+      const xml = await adapter.getJunitReport(runId);
+      const result = writeReportXml(xml, opts.outputPath);
+      if (mode === "json") printJson({ runId, kind: adapter.kind, report: result });
+      else if (result.outPath) {
+        process.stdout.write(
+          `Saved JUnit report for ${adapter.runLabel} ${runId} to ${result.outPath} (${result.size} chars)
+`
+        );
+      } else {
+        process.stdout.write(xml);
+        if (!xml.endsWith("\n")) process.stdout.write("\n");
+      }
+      return;
+    }
+    if (opts.reporter !== void 0 && opts.reporter !== "inline") {
+      throw new Error(`Invalid --reporter: ${opts.reporter}. Expected 'inline' or 'junit'.`);
+    }
+    const status = await adapter.getRun(runId);
+    if (mode === "json") printJson(status);
+    else process.stdout.write(formatInlineRunReport(adapter.kind, status));
+    const code = exitCodeForStatus(status.status);
+    if (code !== 0) exitWith(code);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+};
+var stopExistingRunAction = async (runId, adapter) => {
+  const mode = resolveOutputMode();
+  try {
+    const status = await adapter.stopRun(runId);
+    if (mode === "json") printJson(status);
+    else process.stdout.write(`Status: ${status.status}
+`);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+};
+var getExistingRunReportAction = async (runId, opts, adapter) => {
+  const mode = resolveOutputMode();
+  try {
+    const xml = await adapter.getJunitReport(runId);
+    const result = writeReportXml(xml, opts.output);
+    if (mode === "json") {
+      printJson({ runId, kind: adapter.kind, ...result });
+      return;
+    }
+    if (result.outPath) {
+      process.stdout.write(
+        `Saved JUnit report for ${adapter.runLabel} ${runId} to ${result.outPath} (${result.size} chars)
+`
+      );
+    } else {
+      process.stdout.write(xml);
+      if (!xml.endsWith("\n")) process.stdout.write("\n");
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+};
+
+// src/features/suiteRuns/suiteRuns.command.ts
+var SUITE_RUN_ACTION_ADAPTER = {
+  kind: "suite",
+  runLabel: "suite run",
+  getRun: getSuiteRun,
+  getJunitReport: getSuiteRunJunitReport,
+  stopRun: stopSuiteRun
+};
+var registerSuiteRunShowCommand = (parent, commandName = "show") => parent.command(`${commandName} <runId>`).description("Show suite run details").option("--reporter <name>", "Reporter to use: inline or junit", "inline").option("--output-path <path>", "Path to save the suite report").action(
+  (runId, opts) => getExistingRunResultAction(runId, opts, SUITE_RUN_ACTION_ADAPTER)
+);
+var registerSuiteRunStopCommand = (parent, commandName = "stop") => parent.command(`${commandName} <runId>`).description("Stop a suite run").action((runId) => stopExistingRunAction(runId, SUITE_RUN_ACTION_ADAPTER));
+var registerSuiteRunReportCommand = (parent, commandName = "report") => parent.command(`${commandName} <runId>`).description("Get JUnit XML report for a suite run").option("-o, --output <file>", "Output file path (prints to stdout if omitted)").action(
+  (runId, opts) => getExistingRunReportAction(runId, opts, SUITE_RUN_ACTION_ADAPTER)
+);
+var registerSuiteRunsCommand = (program2) => {
+  const suiteruns = program2.command("suiteruns").description("Suite run commands");
+  registerSuiteRunShowCommand(suiteruns, "show");
+  registerSuiteRunStopCommand(suiteruns, "stop");
+  registerSuiteRunReportCommand(suiteruns, "report");
+  return suiteruns;
+};
+
+// src/utils/runAction.ts
+import { createElement } from "react";
+var collectRunVariableOption = (val, prev = []) => prev.concat(val);
+var parseTimeoutMinutes = (value) => {
+  const minutes = Number(value);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    throw new Error(`Invalid --timeout: ${value}. Expected a positive number of minutes.`);
+  }
+  return minutes * 6e4;
+};
+var runResourceAction = async (resourceId, opts, adapter) => {
+  const mode = resolveOutputMode();
+  try {
+    const reporter = validateReporterOptions(opts);
+    const variables = getVariablesMap(opts.variables ?? []);
+    const runResult = await adapter.runResource(resourceId, {
+      profile: opts.profile,
+      variables: Object.keys(variables).length ? variables : void 0
+    });
+    if (mode === "plain") {
+      process.stdout.write(
+        `Starting ${adapter.runLabel} for ${adapter.entityLabel} id: ${resourceId}
+`
+      );
+      if (opts.profile) process.stdout.write(`Using profile: ${opts.profile}
+`);
+      if (Object.keys(variables).length) {
+        process.stdout.write(`Variables: ${JSON.stringify(variables)}
+`);
+      }
+      process.stdout.write(`${capitalize(adapter.runLabel)} id: ${runResult.id}
+`);
+    }
+    if (opts.wait === false) {
+      if (mode === "json") {
+        printJson(runResult.state);
+      }
+      return;
+    }
+    let finalState;
+    if (mode === "interactive") {
+      let interactiveState;
+      let interactiveError;
+      const RunDetailsComponent = adapter.kind === "suite" ? BaseSuiteRunDetails : BaseTestRunDetails;
+      const { waitUntilExit } = await render(
+        createElement(RunDetailsComponent, {
+          runId: runResult.id,
+          headless: true,
+          timeoutMs: opts.timeout,
+          onComplete: (status) => {
+            interactiveState = status;
+          },
+          onError: (err) => {
+            interactiveError = err;
+          }
+        })
+      );
+      await waitUntilExit();
+      if (interactiveError) {
+        const error = interactiveError;
+        throw error;
+      }
+      if (!interactiveState) {
+        throw new Error(
+          `${capitalize(adapter.runLabel)} ${runResult.id} finished without a final status.`
+        );
+      }
+      finalState = interactiveState;
+    } else {
+      let lastStatus = "";
+      finalState = await adapter.waitForRun(
+        runResult.id,
+        4e3,
+        (status) => {
+          if (status.status !== lastStatus) {
+            lastStatus = status.status;
+            if (mode === "plain") {
+              process.stdout.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] status: ${status.status}
+`);
+            }
+          }
+        },
+        opts.timeout
+      );
+    }
+    let reportResult;
+    if (reporter === "junit") {
+      const xml = await adapter.getJunitReport(runResult.id);
+      const writeReport = adapter.writeReport ?? writeReportXml;
+      reportResult = writeReport(
+        xml,
+        opts.outputPath ?? defaultJunitReportPath(adapter.kind, runResult.id)
+      );
+    }
+    if (mode === "json") {
+      const payload = reportResult ? { ...finalState, report: { kind: "junit", ...reportResult } } : finalState;
+      printJson(payload);
+    } else if (mode === "plain" || mode === "interactive") {
+      if (reportResult?.outPath) {
+        process.stdout.write(
+          `Saved JUnit report for ${adapter.runLabel} ${runResult.id} to ${reportResult.outPath} (${reportResult.size} chars)
+`
+        );
+      }
+      if (mode === "plain") {
+        if (reporter === "inline") {
+          process.stdout.write(formatInlineRunReport(adapter.kind, finalState));
+        } else {
+          process.stdout.write(`Final status: ${finalState.status}
+`);
+        }
+      }
+    }
+    const code = exitCodeForStatus(finalState.status);
+    if (code !== 0) exitWith(code);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+};
+
+// src/features/suites/suites.formatters.tsx
+var suitesListOutputFormatters = {
+  toPlain(suites) {
+    return renderTable(
+      suites,
+      [
+        { header: "Id", get: (s) => s.id },
+        { header: "Name", get: (s) => s.name ?? "" },
+        { header: "Tests", get: (s) => s.testsCount != null ? String(s.testsCount) : "" }
+      ],
+      { emptyMessage: "No suites found." }
+    );
+  },
+  toJson(suites) {
+    return suites;
+  }
+};
+var suiteDetailsOutputFormatters = {
+  toPlain(suite) {
+    return renderTable(
+      [suite],
+      [
+        { header: "Id", get: (s) => s.id },
+        { header: "Name", get: (s) => s.name ?? "" },
+        { header: "Tests", get: (s) => s.testsCount != null ? String(s.testsCount) : "" },
+        { header: "URL", get: (s) => s.webappUrl ?? "" }
+      ]
+    );
+  },
+  toJson(suite) {
+    return suite;
+  }
+};
+
+// src/features/suites/suites.command.ts
+var registerSuitesListCommand = (parent, commandName = "list") => parent.command(commandName).description("List all available test suites").option("-s, --search <query>", "Filter suites by name").action(async (opts) => {
+  const mode = resolveOutputMode();
+  try {
+    const query = opts.search?.trim() || void 0;
+    const data = await listSuites({ query });
+    await renderOutput(mode, data, suitesListOutputFormatters);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerSuiteShowCommand = (parent, commandName = "show") => parent.command(`${commandName} <suiteId>`).description("Show suite details").action(async (suiteId) => {
+  const mode = resolveOutputMode();
+  try {
+    const data = await getSuite(suiteId);
+    await renderOutput(mode, data, suiteDetailsOutputFormatters);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerSuiteRunCommand = (parent, commandName = "run") => parent.command(`${commandName} <suiteId>`).description("Execute a test suite by ID").option("-p, --profile <name>", "Profile name to use").option("--reporter <name>", "Reporter to use: inline or junit", "inline").option("--output-path <path>", "Path to save the test report").option(
+  "--variable <key=value>",
+  "Override variables (repeatable)",
+  collectRunVariableOption,
+  []
+).option("--no-wait", "Queue the run and exit without waiting for completion").option("--timeout <minutes>", "Maximum wait time in minutes", parseTimeoutMinutes).action(
+  (suiteId, opts) => runResourceAction(
+    suiteId,
+    { ...opts, variables: opts.variable ?? [] },
+    {
+      kind: "suite",
+      entityLabel: "suite",
+      runLabel: "suite run",
+      runResource: runSuite,
+      waitForRun: waitForSuiteRun,
+      getJunitReport: getSuiteRunJunitReport
+    }
+  )
+);
+var registerSuitesCommand = (program2) => {
+  const suites = program2.command("suites").description("Test suite commands");
+  registerSuiteShowCommand(suites, "show");
+  registerSuiteRunCommand(suites, "run");
+  registerSuitesListCommand(suites, "list");
+  return suites;
+};
+
+// src/features/testRuns/testRuns.command.ts
+var TEST_RUN_ACTION_ADAPTER = {
+  kind: "test",
+  runLabel: "test run",
+  getRun: getTestRun,
+  getJunitReport: getTestRunJunitReport,
+  stopRun: stopTestRun
+};
+var registerTestRunLogsCommand = (parent, commandName = "logs") => parent.command(`${commandName} <runId>`).description("Get logs for a test run").action(async (runId) => {
+  const mode = resolveOutputMode();
+  try {
+    const logs = await getTestRunLogs(runId);
+    if (mode === "json") {
+      printJson({ runId, logs });
+    } else {
+      if (mode === "plain") process.stdout.write(`Logs for test run ${runId}:
+
+`);
+      process.stdout.write(logs);
+      if (!logs.endsWith("\n")) process.stdout.write("\n");
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerTestRunShowCommand = (parent, commandName = "show") => parent.command(`${commandName} <runId>`).description("Show test run details").option("--reporter <name>", "Reporter to use: inline or junit", "inline").option("--output-path <path>", "Path to save the test report").action(
+  (runId, opts) => getExistingRunResultAction(runId, opts, TEST_RUN_ACTION_ADAPTER)
+);
+var registerTestRunStopCommand = (parent, commandName = "stop") => parent.command(`${commandName} <runId>`).description("Stop a test run").action((runId) => stopExistingRunAction(runId, TEST_RUN_ACTION_ADAPTER));
+var registerTestRunReportCommand = (parent, commandName = "report") => parent.command(`${commandName} <runId>`).description("Get JUnit XML report for a test run").option("-o, --output <file>", "Output file path (prints to stdout if omitted)").action(
+  (runId, opts) => getExistingRunReportAction(runId, opts, TEST_RUN_ACTION_ADAPTER)
+);
+var registerTestRunsCommand = (program2) => {
+  const testruns = program2.command("testruns").description("Test run commands");
+  registerTestRunShowCommand(testruns, "show");
+  registerTestRunStopCommand(testruns, "stop");
+  registerTestRunLogsCommand(testruns, "logs");
+  registerTestRunReportCommand(testruns, "report");
+  return testruns;
+};
+
+// src/features/tests/tests.formatters.tsx
+var testsListOutputFormatters = {
+  toPlain(tests) {
+    return renderTable(
+      tests,
+      [
+        { header: "Id", get: (t) => t.id },
+        { header: "Name", get: (t) => t.name ?? "" }
+      ],
+      { emptyMessage: "No tests found." }
+    );
+  },
+  toJson(tests) {
+    return tests;
+  }
+};
+var testDetailsOutputFormatters = {
+  toPlain(test) {
+    return renderTable(
+      [test],
+      [
+        { header: "Id", get: (t) => t.id },
+        { header: "Name", get: (t) => t.name ?? "" },
+        { header: "URL", get: (t) => t.webappUrl ?? "" }
+      ]
+    );
+  },
+  toJson(test) {
+    return test;
+  }
+};
+
+// src/features/tests/tests.command.ts
+var registerTestsListCommand = (parent, commandName = "list") => parent.command(commandName).description("List all available tests").option("-s, --search <query>", "Filter tests by name").action(async (opts) => {
+  const mode = resolveOutputMode();
+  try {
+    const query = opts.search?.trim() || void 0;
+    const data = await listTests({ query });
+    await renderOutput(mode, data, testsListOutputFormatters);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerTestShowCommand = (parent, commandName = "show") => parent.command(`${commandName} <testId>`).description("Show test details").action(async (testId) => {
+  const mode = resolveOutputMode();
+  try {
+    const data = await getTest(testId);
+    await renderOutput(mode, data, testDetailsOutputFormatters);
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerTestRunCommand = (parent, commandName = "run") => parent.command(`${commandName} <testId>`).description("Execute a test by ID").option("-p, --profile <name>", "Profile name to use").option("--reporter <name>", "Reporter to use: inline or junit", "inline").option("--output-path <path>", "Path to save the test report").option(
+  "--variable <key=value>",
+  "Override variables (repeatable)",
+  collectRunVariableOption,
+  []
+).option("--no-wait", "Queue the run and exit without waiting for completion").option("--timeout <minutes>", "Maximum wait time in minutes", parseTimeoutMinutes).action(
+  (testId, opts) => runResourceAction(
+    testId,
+    { ...opts, variables: opts.variable ?? [] },
+    {
+      kind: "test",
+      entityLabel: "test",
+      runLabel: "test run",
+      runResource: runTest,
+      waitForRun: waitForTestRun,
+      getJunitReport: getTestRunJunitReport
+    }
+  )
+);
+var registerTestExportCommand = (parent, commandName = "export") => parent.command(`${commandName} <testId>`).description("Export a single test as YAML or ZIP").option("--format <fmt>", "Output format: yaml or zip", "yaml").option("-o, --output <file>", "Output file path (defaults to bugbug-test-<testId>.<fmt>)").action(async (testId, opts) => {
+  const mode = resolveOutputMode();
+  try {
+    const fmt = (opts.format ?? "yaml").toLowerCase();
+    if (fmt !== "yaml" && fmt !== "zip") {
+      throw new Error(`Invalid --format: ${opts.format}. Expected 'yaml' or 'zip'.`);
+    }
+    const result = await exportTest(testId, fmt, opts.output);
+    if (mode === "json") {
+      printJson(result);
+    } else {
+      process.stdout.write(
+        `Exported test ${testId} to ${result.outPath} (${result.size} ${fmt === "yaml" ? "chars" : "bytes"})
+`
+      );
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerTestImportCommand = (parent, commandName = "import") => parent.command(`${commandName} <file>`).description("Import a test from a YAML or ZIP file").option("--conflict-mode <mode>", "Conflict handling mode for existing imported resources").action(async (file, opts) => {
+  const mode = resolveOutputMode();
+  try {
+    const fmt = detectFormat(file);
+    if (mode === "plain") {
+      process.stdout.write(`Importing test from ${file} as ${fmt}...
+`);
+    }
+    const result = await importTest(file, {
+      conflictMode: opts.conflictMode
+    });
+    if (mode === "json") {
+      printJson(result);
+    } else {
+      const id = result.id ?? "(unknown)";
+      const name = result.name ?? "";
+      process.stdout.write(`Imported test: ${id}${name ? ` (${name})` : ""}
+`);
+    }
+  } catch (err) {
+    emitError(mode, { error: err instanceof Error ? err.message : String(err) });
+    exitWith(EXIT_GENERAL_ERROR);
+  }
+});
+var registerTestsCommand = (program2) => {
+  const tests = program2.command("tests").description("Test commands");
+  registerTestShowCommand(tests, "show");
+  registerTestRunCommand(tests, "run");
+  registerTestsListCommand(tests, "list");
+  registerTestExportCommand(tests, "export");
+  registerTestImportCommand(tests, "import");
+  return tests;
+};
+
+// src/features/shorthands/shorthands.command.ts
+var registerRunShorthand = (program2) => {
+  const run = program2.command("run").description("Run tests or suites");
+  registerTestRunCommand(run, "test");
+  registerSuiteRunCommand(run, "suite");
+  return run;
+};
+var registerListShorthand = (program2) => {
+  const list = program2.command("list").description("List BugBug resources");
+  registerTestsListCommand(list, "test");
+  registerSuitesListCommand(list, "suite");
+  registerProfilesListCommand(list, "profile");
+  return list;
+};
+var registerStopShorthand = (program2) => {
+  const stop = program2.command("stop").description("Stop a running test or suite");
+  registerTestRunStopCommand(stop, "test");
+  registerSuiteRunStopCommand(stop, "suite");
+  return stop;
+};
+var registerLogsShorthand = (program2) => {
+  const logs = program2.command("logs").description("Get logs for test runs");
+  registerTestRunLogsCommand(logs, "test");
+  return logs;
+};
+var registerExportShorthand = (program2) => {
+  const exportCmd = program2.command("export").description("Export commands");
+  registerProjectExportCommand(exportCmd, "project");
+  registerTestExportCommand(exportCmd, "test");
+  return exportCmd;
+};
+var registerImportShorthand = (program2) => {
+  const importCmd = program2.command("import").description("Import commands");
+  registerProjectImportCommand(importCmd, "project");
+  registerTestImportCommand(importCmd, "test");
+  return importCmd;
+};
+var registerShorthandCommands = (program2) => {
+  registerProjectInitCommand(program2, "init");
+  registerRunShorthand(program2);
+  registerListShorthand(program2);
+  registerStopShorthand(program2);
+  registerLogsShorthand(program2);
+  registerExportShorthand(program2);
+  registerImportShorthand(program2);
+};
+
+// src/utils/command.ts
+var getFullCommandPath = (command) => {
+  const names = [command.name()];
+  let current = command.parent;
+  while (current) {
+    names.unshift(current.name());
+    current = current.parent;
+  }
+  return names.join(" ");
+};
+
+// src/utils/startup.ts
+var GLOBAL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["-t", "--token", "-p", "--project-id"]);
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["-v", "--verbose", "--disable-telemetry", "--ci", "--json"]);
+var GLOBAL_FLAGS_WITH_EQUALS_VALUE = ["--token=", "--project-id="];
+var AUTH_REDIRECT_EXEMPT_TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "plugin",
+  "mcp",
+  "login",
+  "logout"
+]);
+var TOP_LEVEL_ROUTES = /* @__PURE__ */ new Set([
+  "tests",
+  "testruns",
+  "suites",
+  "suiteruns",
+  "profiles",
+  "project",
+  "settings",
+  "init"
+]);
+var routeWithId = (build) => (id) => {
+  if (!id) throw new Error("Route command requires an id");
+  return build(id);
+};
+var RESOURCE_COMMAND_ROUTES = {
+  tests: {
+    list: { args: 0, build: () => "/tests/list" },
+    show: { args: 1, build: routeWithId((id) => `/tests/${id}`) },
+    run: { args: 1, build: routeWithId((id) => `/tests/${id}/run`) },
+    export: { args: 1, build: routeWithId((id) => `/tests/${id}/export`) }
+  },
+  suites: {
+    list: { args: 0, build: () => "/suites/list" },
+    show: { args: 1, build: routeWithId((id) => `/suites/${id}`) },
+    run: { args: 1, build: routeWithId((id) => `/suites/${id}/run`) }
+  },
+  profiles: {
+    list: { args: 0, build: () => "/profiles/list" }
+  },
+  testruns: {
+    show: { args: 1, build: routeWithId((id) => `/testruns/${id}`) }
+  },
+  suiteruns: {
+    show: { args: 1, build: routeWithId((id) => `/suiteruns/${id}`) }
+  }
+};
+var SHORTHAND_COMMAND_ROUTES = {
+  list: {
+    test: { args: 0, build: () => "/tests/list" },
+    suite: { args: 0, build: () => "/suites/list" },
+    profile: { args: 0, build: () => "/profiles/list" }
+  },
+  run: {
+    test: { args: 1, build: routeWithId((id) => `/tests/${id}/run`) },
+    suite: { args: 1, build: routeWithId((id) => `/suites/${id}/run`) }
+  },
+  export: {
+    test: { args: 1, build: routeWithId((id) => `/tests/${id}/export`) },
+    project: { args: 0, build: () => "/project/export" }
+  }
+};
+var getTableRoute = (positionals, routes) => {
+  const [resource, action, id] = positionals;
+  if (!resource || !action) return void 0;
+  const routeCommand = routes[resource]?.[action];
+  if (!routeCommand || positionals.length !== 2 + routeCommand.args) return void 0;
+  return routeCommand.build(id);
+};
+var getCommandRoute = (positionals, hasCommandOptions) => {
+  if (hasCommandOptions) return void 0;
+  const [resource, action] = positionals;
+  if (positionals.length === 1 && resource && TOP_LEVEL_ROUTES.has(resource)) {
+    return `/${resource}`;
+  }
+  if (resource === "run" && action && positionals.length === 2) return `/tests/${action}/run`;
+  return getTableRoute(positionals, RESOURCE_COMMAND_ROUTES) ?? getTableRoute(positionals, SHORTHAND_COMMAND_ROUTES);
+};
+var parseStartupArgs = (argv) => {
+  const args = argv.slice(2);
+  const hasExplicitHelp = args.includes("--help") || args.includes("-h");
+  const hasExplicitVersion = args.includes("--version") || args.includes("-V");
+  const positionals = [];
+  let forceHelp = false;
+  let forceJson = false;
+  let hasCommandOptions = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (GLOBAL_FLAGS.has(arg)) {
+      if (arg === "--ci") forceHelp = true;
+      if (arg === "--json") forceJson = true;
+      continue;
+    }
+    if (GLOBAL_FLAGS_WITH_VALUE.has(arg)) {
+      i++;
+      continue;
+    }
+    if (GLOBAL_FLAGS_WITH_EQUALS_VALUE.some((flag) => arg.startsWith(flag))) continue;
+    if (arg.startsWith("-")) {
+      hasCommandOptions = true;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return {
+    positionals,
+    forceHelp,
+    forceJson,
+    hasCommandOptions,
+    hasExplicitHelpOrVersion: hasExplicitHelp || hasExplicitVersion
+  };
+};
+var isInteractiveStartup = (args) => Boolean(process.stdout.isTTY) && process.env.CI !== "true" && !args.forceHelp && !args.forceJson;
+var isAuthRedirectExemptCommand = (positionals) => {
+  const [command, subcommand] = positionals;
+  if (!command) return true;
+  if (AUTH_REDIRECT_EXEMPT_TOP_LEVEL_COMMANDS.has(command)) return true;
+  return command === "project" && subcommand === "init";
+};
+var shouldRedirectUnauthenticatedCommandToInit = (argv, authenticated) => {
+  if (authenticated) return false;
+  const args = parseStartupArgs(argv);
+  if (args.hasExplicitHelpOrVersion || !isInteractiveStartup(args)) return false;
+  if (args.positionals.length === 0) return false;
+  if (isAuthRedirectExemptCommand(args.positionals)) return false;
+  return true;
+};
+var getStartupMode = (argv) => {
+  const args = parseStartupArgs(argv);
+  if (args.hasExplicitHelpOrVersion) return { type: "commandline" };
+  const interactive = isInteractiveStartup(args);
+  const commandRoute = interactive ? getCommandRoute(args.positionals, args.hasCommandOptions) : void 0;
+  if (commandRoute) return { type: "navigator", route: commandRoute };
+  if (args.positionals.length > 0 || args.forceJson) return { type: "commandline" };
+  if (args.forceHelp || !interactive) return { type: "help" };
+  return { type: "navigator" };
+};
+
+// src/index.ts
+process.on("uncaughtException", async (err) => {
+  captureException(err);
+  await closeSentry();
+  showError(formatErrorMessage(err));
+  process.exit(1);
+});
+process.on("unhandledRejection", async (reason) => {
+  captureException(reason);
+  await closeSentry();
+  showError(formatErrorMessage(reason));
+  process.exit(1);
+});
+var version = getVersion();
+var program = new Command();
+program.name("bugbug").description(`BugBug CLI ${version}`).version(version).showSuggestionAfterError().option("-t, --token <token>", "API token for BugBug (overrides config)").option(
+  "-p, --project-id <projectId>",
+  "Required only for organization tokens in non-interactive mode"
+).option("-v, --verbose", "Enable verbose logging including HTTP requests").option("--ci", "CI-friendly output (plain logs, no interactive UI, exit 1 on failure)").option("--json", "Emit JSON output (implies non-interactive)").option("--disable-telemetry", "Disable telemetry");
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+  const commandName = actionCommand.name();
+  const parent = actionCommand.parent?.name();
+  const fullCommand = getFullCommandPath(actionCommand);
+  setSentryTag("Command", commandName);
+  if (parent && parent !== "bugbug") {
+    setSentryTag("Full command", fullCommand);
+    setSentryTag("Command", parent);
+  }
+  addBreadcrumb(`Run "${fullCommand}" command`, "Command");
+  analytics.trackEvent("cli_command_used", {
+    command: fullCommand
+  });
+});
+registerTestsCommand(program);
+registerTestRunsCommand(program);
+registerSuitesCommand(program);
+registerSuiteRunsCommand(program);
+registerProfilesCommand(program);
+registerProjectCommand(program);
+registerAuthCommands(program);
+registerInstallCommands(program);
+registerShorthandCommands(program);
+program.exitOverride();
+(async () => {
+  try {
+    const config = getCliConfig();
+    const startupMode = getStartupMode(process.argv);
+    analytics.setGlobalEventData({
+      outputMode: config.outputMode,
+      startupMode: startupMode.type
+    });
+    analytics.trackEvent("cli_session_started");
+    if (startupMode.type === "commandline" && shouldRedirectUnauthenticatedCommandToInit(
+      process.argv,
+      Boolean(config.token && config.projectId)
+    )) {
+      const { startNavigator } = await import("./app-A4ZLLFP5.js");
+      await startNavigator({
+        initialRoute: "/init",
+        initialRouteState: {
+          redirectUrl: "/",
+          onlyThisSession: true
+        }
+      });
+      analytics.trackEvent("cli_session_ended", { success: true });
+      return;
+    }
+    if (startupMode.type === "navigator") {
+      const { startNavigator } = await import("./app-A4ZLLFP5.js");
+      await startNavigator({
+        initialRoute: startupMode.route,
+        token: config.token,
+        projectId: config.projectId
+      });
+      analytics.trackEvent("cli_session_ended", { success: true });
+      return;
+    }
+    if (startupMode.type === "help") {
+      program.outputHelp();
+      analytics.trackEvent("cli_session_ended", { success: true });
+      return;
+    }
+    await startSentrySpan(
+      {
+        op: "cli.command",
+        name: `bugbug ${startupMode.type}`
+      },
+      async (span) => {
+        span.setAttribute("startup_mode", startupMode.type);
+        await program.parseAsync(process.argv);
+      }
+    );
+    analytics.trackEvent("cli_session_ended", { success: true });
+  } catch (err) {
+    analytics.trackEvent("cli_session_ended", { success: false });
+    if (err instanceof CommanderError) {
+      process.exit(err.exitCode);
+    }
+    captureException(err);
+    await closeSentry();
+    showError(formatErrorMessage(err));
+    process.exit(1);
+  }
+})();
+//# sourceMappingURL=index.js.map