@runcofactor/cli 0.10.0

package/dist/index.js

@@ -0,0 +1,982 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  runRemoteTest
+} from "./chunk-GKY2KXO5.js";
+import {
+  runLogin
+} from "./chunk-QFDOWABX.js";
+import {
+  checkForUpdate
+} from "./chunk-N7HFALX3.js";
+import {
+  installConsoleBranding,
+  version
+} from "./chunk-JICSYFRJ.js";
+import "./chunk-CLAWT7BJ.js";
+import "./chunk-WOHL4FTB.js";
+import "./chunk-SJJW77WN.js";
+import {
+  fetchOrExit,
+  isSuperadminToken
+} from "./chunk-3CZU7XCS.js";
+import {
+  envToProfile,
+  getArgValue,
+  hasFlag,
+  readAllStoredTokens,
+  readStoredAuth,
+  resolveConfig,
+  resolveOptionalConfig
+} from "./chunk-A4OFTUVV.js";
+import "./chunk-JWHYXEA2.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/index.ts
+import process4 from "process";
+import { pathToFileURL } from "url";
+
+// src/orgs.ts
+import process from "process";
+async function runOrgs(argv) {
+  const { apiUrl, token } = await resolveConfig(argv);
+  const env = getArgValue(argv, "--env");
+  const auth = await readStoredAuth(env ? envToProfile(env) : void 0);
+  const showAll = hasFlag(argv, "--all");
+  if (showAll) {
+    const res2 = await fetch(`${apiUrl}/superadmin/organizations`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res2.ok) {
+      if (res2.status === 403) {
+        console.error("Superadmin access required for --all");
+      } else {
+        console.error("Failed to fetch organizations. You may need to re-login: canary login");
+      }
+      process.exit(1);
+    }
+    const data2 = await res2.json();
+    if (!data2.ok || !data2.organizations) {
+      console.error("Failed to fetch organizations:", data2.error ?? "Unknown error");
+      process.exit(1);
+    }
+    console.log("All Organizations:\n");
+    for (const org of data2.organizations) {
+      const members = org.memberCount !== void 0 && org.memberCount !== null ? ` (${org.memberCount} members)` : "";
+      console.log(`  ${org.name}${members} [${org.id}]`);
+    }
+    console.log(`
+Total: ${data2.organizations.length} organizations`);
+    return;
+  }
+  const res = await fetch(`${apiUrl}/cli-login/orgs`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    console.error("Failed to fetch organizations. You may need to re-login: canary login");
+    process.exit(1);
+  }
+  const data = await res.json();
+  if (!data.ok || !data.organizations) {
+    console.error("Failed to fetch organizations:", data.error ?? "Unknown error");
+    process.exit(1);
+  }
+  const currentOrgId = auth?.orgId ?? data.currentOrgId;
+  console.log("Organizations:\n");
+  for (const org of data.organizations) {
+    const marker = org.id === currentOrgId ? " *" : "";
+    console.log(`  ${org.name} (${org.role}) [${org.id}]${marker}`);
+  }
+  console.log("\n* = current organization");
+  console.log("To switch: canary login --org <name>");
+}
+
+// src/debug-session.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import process2 from "process";
+async function writeDebugSession(loginUrl, expiresAt, apiUrl) {
+  const dir = path.join(os.homedir(), ".config", "canary-cli");
+  const filePath = path.join(dir, "debug-session.json");
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  await fs.writeFile(
+    filePath,
+    JSON.stringify({ loginUrl, expiresAt, apiUrl, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    { encoding: "utf8", mode: 384 }
+  );
+  return filePath;
+}
+async function runDebugSession(argv) {
+  const { apiUrl, token } = await resolveConfig(argv);
+  const jsonOutput = hasFlag(argv, "--json");
+  try {
+    const res = await fetchOrExit(`${apiUrl}/auth/debug-session/create`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      token
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      if (res.status === 403) {
+        console.error("Error: Forbidden. Debug session creation requires superadmin access.");
+        process2.exit(1);
+      }
+      if (res.status === 404) {
+        console.error(
+          "Error: Endpoint not found. The debug-session feature may not be deployed to this environment."
+        );
+        process2.exit(1);
+      }
+      try {
+        const errorJson = JSON.parse(text);
+        console.error(`Error: ${errorJson.message ?? errorJson.error ?? text}`);
+      } catch {
+        console.error(`Error (${res.status}): ${text || res.statusText}`);
+      }
+      process2.exit(1);
+    }
+    const json = await res.json();
+    if (!json.ok || !json.loginUrl) {
+      console.error(`Error: ${json.message ?? json.error ?? "Failed to create debug session"}`);
+      process2.exit(1);
+    }
+    const filePath = await writeDebugSession(json.loginUrl, json.expiresAt ?? "", apiUrl);
+    if (jsonOutput) {
+      console.log(
+        JSON.stringify(
+          {
+            loginUrl: json.loginUrl,
+            expiresAt: json.expiresAt,
+            sessionFile: filePath
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log("Debug session created successfully.");
+      console.log("");
+      console.log(`Login URL: ${json.loginUrl}`);
+      console.log(`Expires: ${json.expiresAt}`);
+      console.log(`Session saved to: ${filePath}`);
+      console.log("");
+      console.log("Use this URL with Playwright to authenticate as the debug agent.");
+      console.log("The token is single-use and expires in 5 minutes.");
+    }
+  } catch (err) {
+    console.error(`Failed to create debug session: ${err}`);
+    process2.exit(1);
+  }
+}
+
+// src/user-event-tracking.ts
+import process3 from "process";
+
+// ../sdk/src/errors.ts
+var SdkError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "SdkError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var AuthError = class extends SdkError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "AuthError";
+  }
+};
+var ValidationError = class extends SdkError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "ValidationError";
+  }
+};
+function errorFromResponse(status, body) {
+  const message = body?.error ?? `Request failed with status ${status}`;
+  if (status === 401 || status === 403) return new AuthError(message, status, body);
+  if (status === 400 || status === 422) return new ValidationError(message, status, body);
+  return new SdkError(message, status, body);
+}
+
+// ../sdk/src/client.ts
+function interpolate(path2, params) {
+  if (!params) return path2;
+  return path2.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {
+    const v = params[k];
+    if (v === void 0) throw new Error(`Missing path param :${k} for ${path2}`);
+    return encodeURIComponent(String(v));
+  });
+}
+function buildQuery(q) {
+  if (!q) return "";
+  const usp = new URLSearchParams();
+  for (const [k, v] of Object.entries(q)) {
+    if (v === void 0 || v === null) continue;
+    usp.set(k, String(v));
+  }
+  const s = usp.toString();
+  return s ? `?${s}` : "";
+}
+function createClient(cfg) {
+  let token = cfg.token;
+  const fetchImpl = cfg.fetch ?? fetch;
+  async function resolveToken() {
+    if (typeof token === "function") return token();
+    return token;
+  }
+  async function request(method, path2, opts = {}) {
+    const url = cfg.baseUrl.replace(/\/$/, "") + interpolate(path2, opts.params) + buildQuery(opts.query);
+    const headers = {
+      accept: "application/json",
+      ...cfg.headers,
+      ...opts.headers
+    };
+    const resolvedToken = await resolveToken();
+    if (resolvedToken && !headers.authorization) {
+      headers.authorization = `Bearer ${resolvedToken}`;
+    }
+    if (opts.body !== void 0 && !headers["content-type"]) {
+      headers["content-type"] = "application/json";
+    }
+    const res = await fetchImpl(url, {
+      method,
+      headers,
+      body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),
+      signal: opts.signal
+    });
+    const text = await res.text();
+    let parsed;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      const body = parsed && typeof parsed === "object" ? parsed : void 0;
+      throw errorFromResponse(res.status, body);
+    }
+    return parsed;
+  }
+  return {
+    get baseUrl() {
+      return cfg.baseUrl;
+    },
+    request,
+    setToken(next) {
+      token = next;
+    }
+  };
+}
+
+// ../sdk/src/user-events.ts
+async function recordUserEvent(client, input) {
+  await client.request("POST", "/events", {
+    body: input
+  });
+}
+
+// ../user-events/src/recorder.ts
+function createUserEventRecorder(opts) {
+  const safeRecord = async (eventType, metadata) => {
+    try {
+      await recordUserEvent(opts.client, {
+        eventType,
+        origin: opts.origin,
+        metadata
+      });
+    } catch (error) {
+      opts.onError?.(error);
+    }
+  };
+  return {
+    record: safeRecord,
+    recordCommandStarted(metadata) {
+      return safeRecord("command.started", metadata);
+    },
+    recordCommandCompleted(metadata) {
+      return safeRecord("command.completed", metadata);
+    },
+    recordCommandFailed(metadata) {
+      return safeRecord("command.failed", metadata);
+    },
+    recordCommandInstrumentationFailed(metadata) {
+      return safeRecord("command.instrumentation-failed", metadata);
+    }
+  };
+}
+
+// src/user-event-tracking.ts
+var SUBCOMMAND_COMMANDS = /* @__PURE__ */ new Set([
+  "api-catalog",
+  "attachment",
+  "attachments",
+  "auth",
+  "credential",
+  "credential-template",
+  "credential-templates",
+  "docs",
+  "feature-flag",
+  "issues",
+  "knobs",
+  "local",
+  "property",
+  "release",
+  "sandbox",
+  "session",
+  "tag",
+  "tags",
+  "task",
+  "test-suite",
+  "workflow"
+]);
+var UNTRACKED_COMMANDS = /* @__PURE__ */ new Set(["help", "upgrade", "version"]);
+var ProcessExitSignal = class extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code ${exitCode}`);
+    this.name = "ProcessExitSignal";
+    this.exitCode = exitCode;
+  }
+};
+function shouldTrack(argv) {
+  const command = argv[0];
+  if (!command || UNTRACKED_COMMANDS.has(command)) return false;
+  if (argv.includes("--help") || argv.includes("-h")) return false;
+  return true;
+}
+function getSubcommand(argv) {
+  const command = argv[0];
+  if (!command || !SUBCOMMAND_COMMANDS.has(command)) return void 0;
+  const candidate = argv[1];
+  if (!candidate || candidate.startsWith("-")) return void 0;
+  return candidate;
+}
+function getApiHost(apiUrl) {
+  try {
+    return new URL(apiUrl).host;
+  } catch {
+    return void 0;
+  }
+}
+function getArgNames(argv) {
+  return argv.filter((arg) => arg.startsWith("-"));
+}
+function buildBaseMetadata(argv, cliVersion, apiUrl) {
+  const topLevelCommand = argv[0] ?? "unknown";
+  const subcommand = getSubcommand(argv);
+  return {
+    commandPath: subcommand ? `${topLevelCommand} ${subcommand}` : topLevelCommand,
+    topLevelCommand,
+    subcommand,
+    cliVersion,
+    apiHost: getApiHost(apiUrl),
+    isInteractive: Boolean(process3.stdin.isTTY && process3.stdout.isTTY),
+    args: getArgNames(argv)
+  };
+}
+function errorMetadata(error) {
+  return {
+    errorKind: error instanceof Error ? error.name : typeof error,
+    errorName: error instanceof Error ? error.name : void 0,
+    errorMessage: error instanceof Error ? error.message : String(error)
+  };
+}
+async function createCliUserEventRecorder(argv, cliVersion) {
+  if (!shouldTrack(argv)) return null;
+  const config = await resolveOptionalConfig(argv);
+  if (!config) return null;
+  const client = createClient({
+    baseUrl: config.apiUrl,
+    token: config.token
+  });
+  return {
+    recorder: createUserEventRecorder({
+      client,
+      origin: "cli",
+      onError: (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process3.stderr.write(`[canary] user event tracking skipped: ${message}
+`);
+      }
+    }),
+    metadata: buildBaseMetadata(argv, cliVersion, config.apiUrl)
+  };
+}
+async function recordCliInstrumentationFailure(argv, cliVersion, stage, error) {
+  if (!shouldTrack(argv)) return;
+  try {
+    const config = await resolveOptionalConfig(argv);
+    if (!config) return;
+    const client = createClient({
+      baseUrl: config.apiUrl,
+      token: config.token
+    });
+    const recorder = createUserEventRecorder({
+      client,
+      origin: "cli"
+    });
+    await recorder.recordCommandInstrumentationFailed({
+      ...buildBaseMetadata(argv, cliVersion, config.apiUrl),
+      stage,
+      ...errorMetadata(error),
+      reportToSentry: true,
+      sentryFingerprint: ["canary-cli", "instrumentation-failed", stage]
+    });
+  } catch {
+  }
+}
+
+// src/index.ts
+var loadMcp = () => import("./mcp-54IJEOUA.js").then((m) => m.runMcp);
+var loadDebugWorkflow = () => import("./debug-workflow-KOVH5GOP.js").then((m) => m.runDebugWorkflow);
+var loadRecord = () => import("./record-4TR2UIIS.js").then((m) => m.runRecord);
+var loadSession = () => import("./session-MYFNZPRP.js").then((m) => m.runSession);
+var loadLocal = () => import("./local-HICVD6PU.js").then((m) => m.runLocal);
+function printVersion() {
+  console.log(`canary v${version}`);
+}
+function printHelp({ isSuperadmin }) {
+  const lines = [
+    `canary v${version}: Testing and QA CLI`,
+    "",
+    "Usage:",
+    "  canary test-suite <sub-command>       Run and query test suite results",
+    "  canary mcp                              Start MCP server (stdio)",
+    "  canary install [--target <id>]          Install MCP server into Claude, Cursor, etc.",
+    "  canary login [--org <name>] [--app-url https://app.trycanary.ai] [--no-open]",
+    "  canary orgs                            List organizations",
+    "  canary debug <workflowId> [options]    Debug workflow in local headed browser",
+    "  canary record [options]                 Record browser interactions",
+    "  canary local <sub-command>             Set up and manage local testing",
+    "  canary session <sub-command>           Manage local browser sessions",
+    "  canary issues <sub-command>            Search and view issues",
+    "  canary credential <sub-command>        List, create, update, and test credentials",
+    "  canary credential-template <sub-command>  Manage per-application credential templates",
+    "  canary workflow <sub-command>          Inspect workflow definitions",
+    "  canary spec <sub-command>              Author workflows from .canary.md spec files",
+    "  canary api-catalog <sub-command>       Manage API catalog sources and endpoints",
+    "  canary skill <name>                    Install an AI agent skill template"
+  ];
+  lines.push("  canary release <sub-command>            Release QA gate (CI/CD)");
+  lines.push(
+    "  canary application <sub-command>         List and create applications, view linked repos (alias: property)",
+    "  canary task <sub-command>               Manage agent tasks (requires feature flag)",
+    "  canary sandbox <sub-command>            Manage sandbox templates and instances",
+    "  canary attachment <sub-command>          List, upload, and manage attachments",
+    "  canary tag <sub-command>                 List, create, and assign tags",
+    "  canary triage <sub-command>              Read AI triage results for a test suite execution"
+  );
+  if (isSuperadmin) {
+    lines.push(
+      "  canary debug-session [--env dev|local] [--json]  Create browser debug session",
+      "  canary psql <query> [--json]            Execute read-only SQL",
+      "  canary redis <command> [--json]         Execute read-only Redis commands",
+      "  canary docs <sub-command>               Manage documentation pages",
+      "  canary feature-flag <sub-command>       Manage feature flags",
+      "  canary knobs <sub-command>              Manage knobs (global config)"
+    );
+  }
+  lines.push(
+    "  canary auth doctor [--env <env>]        Diagnose auth / corporate-proxy issues",
+    "  canary upgrade                          Upgrade CLI to latest version",
+    "  canary version                          Show version",
+    "  canary help",
+    "",
+    "Test suite sub-commands:",
+    "  run [options]                          Trigger a test suite and stream results",
+    "  list [options]                         List recent test suites",
+    "  get <id> [options]                     Show suite detail with runs",
+    "  diagnostics <workflowId> <runId>       Get failure diagnostic",
+    "  steps <workflowId> <runId>             Get workflow run steps",
+    "",
+    "Test suite run options:",
+    "  --token <key>         API key (or set CANARY_API_TOKEN)",
+    "  --api-url <url>       API URL (default: https://api.trycanary.ai)",
+    "  --application <name|id>  Target a specific application (alias: --property)",
+    "  --environment <name|id>  Target a specific environment",
+    "  --tag <tag>           Filter workflows by tag",
+    "  --name-pattern <pat>  Filter workflows by name pattern",
+    "  --verbose, -v         Show all events",
+    "",
+    "Login options:",
+    "  --org <name>          Select organization by name or ID (for multi-org users)",
+    "",
+    "Login environments:",
+    "  Production:  canary login",
+    "  Dev:         canary login --app-url https://app.dev.trycanary.ai --api-url https://api.dev.trycanary.ai",
+    "  Local:       canary login --app-url http://localhost:5173 --api-url http://localhost:3000",
+    "",
+    "  Or set CANARY_API_URL env var for non-production environments:",
+    "    export CANARY_API_URL=http://localhost:3000"
+  );
+  lines.push(
+    "",
+    "Debug options:",
+    "  --to-step <N>         Stop after step N (1-based, default: all)",
+    "  --env <env>           Environment (local, dev, prod)",
+    "  --verbose, -v         Show all SSE events",
+    "",
+    "Issues sub-commands:",
+    "  list [options]                         List and search issues",
+    "  get <issueId> [options]                Get issue detail with diagnostics",
+    "",
+    "Issues options:",
+    "  --search <query>      Full-text search",
+    "  --severity <level>    Filter: low, medium, high, unknown",
+    "  --status <statuses>   Filter: open, closed, not_a_bug (comma-separated)",
+    "  --application-id <uuid>  Filter by application (alias: --property-id)",
+    "  --page <n>            Page number (default: 1)",
+    "  --page-size <n>       Page size (default: 25)",
+    "  --json                Output raw JSON",
+    "  --format markdown     Output as markdown",
+    "",
+    "Release sub-commands:",
+    "  trigger --application-id <uuid>        Trigger a Release QA run (alias: --property-id)",
+    "  status <run-id> [--json]               Check run status",
+    "  run --application-id <uuid> [--timeout N] Trigger and poll until complete",
+    "",
+    "Record options:",
+    "  --credential <id>    Credential ID (skip interactive selection)",
+    "  --url <startUrl>     URL to navigate to after launch",
+    "  --output <dir>       Local output directory (default: temp dir)",
+    "  --env <env>          Environment (local, dev, prod)",
+    "  --no-upload          Save locally only, skip API upload",
+    ""
+  );
+  if (isSuperadmin) {
+    lines.push(
+      "",
+      "PSQL options:",
+      "  --json                Output results as JSON",
+      "  --query <sql>         SQL query (alternative to positional)",
+      "",
+      "Redis options:",
+      "  --json                Output results as JSON",
+      "",
+      "Feature flag sub-commands:",
+      "  list                               List all flags",
+      "  create <name> [--description <text>]  Create a flag",
+      "  delete <name>                      Delete a flag and its gates",
+      "  enable <name> --org <orgId>        Enable for an org",
+      "  disable <name> --org <orgId>       Disable for an org",
+      "  lifecycle <name> --stage <stage> [--final-value true|false]",
+      "                                     Set lifecycle metadata",
+      "",
+      "Knobs sub-commands:",
+      "  list                               List all knobs",
+      "  get <key>                          Get a knob value",
+      "  set <key> <value> --type <type>    Set a knob value",
+      "  delete <key>                       Delete a knob",
+      "  toggle <key>                       Toggle a boolean knob",
+      "  lifecycle <key> --stage <stage> [--final-value <value>]",
+      "                                     Set lifecycle metadata"
+    );
+  }
+  lines.push("", "Flags:", "  -h, --help     Show help", "  -V, --version  Show version");
+  console.log(lines.join("\n"));
+}
+function printTestHelp() {
+  console.log(
+    [
+      `canary v${version}: Test command`,
+      "",
+      "\x1B[33m\u26A0 `canary test` is deprecated. Use `canary test-suite run` instead.\x1B[0m",
+      "",
+      "Usage:",
+      "  canary test-suite run [options]         Trigger a test suite and stream results",
+      "  canary test-suite list                  List recent test suites",
+      "  canary test-suite get <id>              Show suite detail with runs",
+      "",
+      "Run options:",
+      "  --token <key>          API key (or set CANARY_API_TOKEN)",
+      "  --api-url <url>        API URL (default: https://api.trycanary.ai)",
+      "  --application <name|id>  Target a specific application (alias: --property)",
+      "  --environment <name|id>  Target a specific environment",
+      "  --tag <tag>            Filter workflows by tag",
+      "  --name-pattern <pat>   Filter workflows by name pattern",
+      "  --verbose, -v          Show all events",
+      "",
+      "Examples:",
+      "  canary test-suite run                   Run all workflow tests",
+      "  canary test-suite run --tag smoke       Run smoke-tagged workflows",
+      '  canary test-suite run --property "My App" --environment staging'
+    ].join("\n")
+  );
+}
+var COMMANDS_WITH_UPDATE_CHECK = /* @__PURE__ */ new Set([
+  "test",
+  "login",
+  "orgs",
+  "issues",
+  "release",
+  "debug",
+  "record",
+  "session",
+  "local",
+  "workflow",
+  "credential",
+  "task",
+  "test-suite",
+  "skill",
+  "skills",
+  "sandbox",
+  "attachment",
+  "attachments",
+  "tag",
+  "tags",
+  "api-catalog"
+]);
+var COMMANDS_WITH_HELP = /* @__PURE__ */ new Set([
+  "test",
+  "install",
+  "session",
+  "local",
+  "issues",
+  "credential",
+  "workflow",
+  "release",
+  "skill",
+  "skills",
+  "task",
+  "test-suite",
+  "sandbox",
+  "attachment",
+  "attachments",
+  "tag",
+  "tags",
+  "api-catalog"
+]);
+async function resolveIsSuperadmin() {
+  const envToken = process4.env.CANARY_API_TOKEN;
+  if (envToken) return isSuperadminToken(envToken);
+  const tokens = await readAllStoredTokens();
+  return tokens.some((t) => isSuperadminToken(t));
+}
+function normalizeExitCode(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 1;
+  }
+  return 0;
+}
+async function executeCommand(command, rest) {
+  if (command === "upgrade") {
+    const { runUpgrade } = await import("./upgrade-L2VYMP2V.js");
+    await runUpgrade();
+    return;
+  }
+  if (command === "test") {
+    if (rest.includes("--help") || rest.includes("-h")) {
+      printTestHelp();
+      return;
+    }
+    if (rest.includes("--remote")) {
+      console.warn(
+        "\x1B[33m\u26A0 `canary test --remote` is deprecated and will be removed in a future release.\x1B[0m"
+      );
+      console.warn("  Use `canary test-suite run` instead.\n");
+      const remoteArgs = rest.filter((arg) => arg !== "--remote");
+      await runRemoteTest(remoteArgs);
+      return;
+    }
+    console.error(
+      '`canary test` (local Playwright runner) has been removed.\nUse `canary test-suite run` for remote workflow tests.\n\nExamples:\n  canary test-suite run\n  canary test-suite run --tag smoke\n  canary test-suite run --property "My App" --environment staging'
+    );
+    process4.exit(1);
+  }
+  if (command === "mcp") {
+    const runMcp = await loadMcp();
+    await runMcp(rest);
+    return;
+  }
+  if (command === "install") {
+    const { runInstall } = await import("./install-DXSNWZKO.js");
+    await runInstall(rest);
+    return;
+  }
+  if (command === "login") {
+    await runLogin(rest);
+    return;
+  }
+  if (command === "orgs") {
+    await runOrgs(rest);
+    return;
+  }
+  if (command === "debug") {
+    const runDebugWorkflow = await loadDebugWorkflow();
+    await runDebugWorkflow(rest);
+    return;
+  }
+  if (command === "record") {
+    const runRecord = await loadRecord();
+    await runRecord(rest);
+    return;
+  }
+  if (command === "session") {
+    const runSession = await loadSession();
+    await runSession(rest);
+    return;
+  }
+  if (command === "local") {
+    const runLocal = await loadLocal();
+    await runLocal(rest);
+    return;
+  }
+  if (command === "debug-session") {
+    await runDebugSession(rest);
+    return;
+  }
+  if (command === "psql") {
+    const { runPsql } = await import("./psql-BYUUNLGG.js");
+    await runPsql(rest);
+    return;
+  }
+  if (command === "redis") {
+    const { runRedis } = await import("./redis-35VBUYW7.js");
+    await runRedis(rest);
+    return;
+  }
+  if (command === "release") {
+    const { runRelease } = await import("./release-OOLTUBUT.js");
+    await runRelease(rest);
+    return;
+  }
+  if (command === "docs") {
+    const { runDocs } = await import("./docs-3SSORHB5.js");
+    await runDocs(rest);
+    return;
+  }
+  if (command === "feature-flag") {
+    const { runFeatureFlag } = await import("./feature-flag-T2LRZME3.js");
+    await runFeatureFlag(rest);
+    return;
+  }
+  if (command === "scenarios" || command === "scenario") {
+    const { runScenarios } = await import("./scenarios-GWLJEGHA.js");
+    await runScenarios(rest);
+    return;
+  }
+  if (command === "knobs") {
+    const { runKnobs } = await import("./knobs-NBINZIUB.js");
+    await runKnobs(rest);
+    return;
+  }
+  if (command === "issues") {
+    const { runIssues } = await import("./issues-XIZOPX6T.js");
+    await runIssues(rest);
+    return;
+  }
+  if (command === "credential") {
+    const { runCredential } = await import("./credential-COLTBV6D.js");
+    await runCredential(rest);
+    return;
+  }
+  if (command === "credential-template" || command === "credential-templates") {
+    const { runCredentialTemplate } = await import("./credential-template-EEPYFG7R.js");
+    await runCredentialTemplate(rest);
+    return;
+  }
+  if (command === "workflow") {
+    const { runWorkflow } = await import("./workflow-XYFH5LTP.js");
+    await runWorkflow(rest);
+    return;
+  }
+  if (command === "spec") {
+    const { resolveConfig: resolveConfig2 } = await import("./auth-EN6NQCJY.js");
+    const { handleSpec } = await import("./spec-RA3CFEKG.js");
+    const wantsAuth = rest[0] === "compile" || rest[0] === "pull" || rest[0] === "diff";
+    if (wantsAuth) {
+      const { apiUrl, token } = await resolveConfig2(rest);
+      await handleSpec(rest, apiUrl, token);
+    } else {
+      await handleSpec(rest, "", "");
+    }
+    return;
+  }
+  if (command === "api-catalog") {
+    const { resolveConfig: resolveConfig2 } = await import("./auth-EN6NQCJY.js");
+    const { runApiCatalog } = await import("./api-catalog-GFGCLVS4.js");
+    const { apiUrl, token } = await resolveConfig2(rest);
+    await runApiCatalog(rest, apiUrl, token);
+    return;
+  }
+  if (command === "skill" || command === "skills") {
+    const { runSkill } = await import("./skill-KM34LDMO.js");
+    await runSkill(rest);
+    return;
+  }
+  if (command === "task") {
+    const { runTask } = await import("./task-IQC3YR5K.js");
+    await runTask(rest);
+    return;
+  }
+  if (command === "test-suite") {
+    const { runTestSuite } = await import("./test-suite-DZNJFXDW.js");
+    await runTestSuite(rest);
+    return;
+  }
+  if (command === "triage") {
+    const { runTriage } = await import("./triage-ORG45R5W.js");
+    await runTriage(rest);
+    return;
+  }
+  if (command === "application" || command === "applications" || command === "property" || command === "properties") {
+    const { runProperty } = await import("./property-UXLOLPTD.js");
+    await runProperty(rest);
+    return;
+  }
+  if (command === "sandbox") {
+    const { runSandbox } = await import("./sandbox-XGSUU6G7.js");
+    await runSandbox(rest);
+    return;
+  }
+  if (command === "attachment" || command === "attachments") {
+    const { runAttachment } = await import("./attachment-SJC7D7FY.js");
+    await runAttachment(rest);
+    return;
+  }
+  if (command === "tag" || command === "tags") {
+    const { runTag } = await import("./tag-YY6YAABQ.js");
+    await runTag(rest);
+    return;
+  }
+  if (command === "trace") {
+    const { runTrace } = await import("./trace-HXIW7U2D.js");
+    await runTrace(rest);
+    return;
+  }
+  if (command === "auth") {
+    const sub = rest[0];
+    if (sub === "doctor") {
+      const { runAuthDoctor } = await import("./doctor-OTSIWV6G.js");
+      await runAuthDoctor(rest.slice(1));
+      return;
+    }
+    console.error("Usage: canary auth doctor [--env <env>]");
+    process4.exit(1);
+  }
+  console.log(`Unknown command "${command}".`);
+  printHelp({ isSuperadmin: await resolveIsSuperadmin() });
+  process4.exit(1);
+}
+async function main(argv) {
+  const wantsMachineOutput = argv.includes("--json") || argv.includes("--format");
+  if (argv[0] !== "mcp" && !wantsMachineOutput) {
+    installConsoleBranding();
+  }
+  if (argv.includes("--version") || argv.includes("-V")) {
+    printVersion();
+    return;
+  }
+  const [command, ...rest] = argv;
+  const hasHelpFlag = argv.includes("--help") || argv.includes("-h");
+  if (hasHelpFlag && (!command || !COMMANDS_WITH_HELP.has(command))) {
+    printHelp({ isSuperadmin: await resolveIsSuperadmin() });
+    return;
+  }
+  if (!command || command === "help") {
+    printHelp({ isSuperadmin: await resolveIsSuperadmin() });
+    return;
+  }
+  if (command === "version") {
+    printVersion();
+    return;
+  }
+  if (command && COMMANDS_WITH_UPDATE_CHECK.has(command)) {
+    await checkForUpdate(version);
+  }
+  let tracking = null;
+  try {
+    tracking = await createCliUserEventRecorder(argv, version);
+  } catch (error) {
+    await recordCliInstrumentationFailure(argv, version, "recorder-init", error);
+  }
+  const startedAt = Date.now();
+  const originalExit = process4.exit.bind(process4);
+  let finalExitCode = 0;
+  if (tracking) {
+    await tracking.recorder.recordCommandStarted(tracking.metadata);
+  }
+  process4.exit = ((code) => {
+    throw new ProcessExitSignal(code ?? normalizeExitCode(process4.exitCode));
+  });
+  try {
+    await executeCommand(command, rest);
+    finalExitCode = normalizeExitCode(process4.exitCode);
+    if (tracking) {
+      const metadata = {
+        ...tracking.metadata,
+        durationMs: Date.now() - startedAt,
+        exitCode: finalExitCode
+      };
+      if (finalExitCode === 0) {
+        await tracking.recorder.recordCommandCompleted(metadata);
+      } else {
+        await tracking.recorder.recordCommandFailed({
+          ...metadata,
+          errorKind: "exit-code"
+        });
+      }
+    }
+  } catch (error) {
+    if (error instanceof ProcessExitSignal) {
+      finalExitCode = error.exitCode;
+      if (tracking) {
+        const metadata = {
+          ...tracking.metadata,
+          durationMs: Date.now() - startedAt,
+          exitCode: finalExitCode
+        };
+        if (finalExitCode === 0) {
+          await tracking.recorder.recordCommandCompleted(metadata);
+        } else {
+          await tracking.recorder.recordCommandFailed({
+            ...metadata,
+            errorKind: "process-exit"
+          });
+        }
+      }
+    } else {
+      finalExitCode = normalizeExitCode(process4.exitCode) || 1;
+      if (tracking) {
+        await tracking.recorder.recordCommandFailed({
+          ...tracking.metadata,
+          durationMs: Date.now() - startedAt,
+          exitCode: finalExitCode,
+          errorKind: error instanceof Error ? error.name : typeof error,
+          errorName: error instanceof Error ? error.name : void 0,
+          errorMessage: error instanceof Error ? error.message : String(error),
+          reportToSentry: true,
+          sentryFingerprint: [
+            "canary-cli",
+            tracking.metadata.commandPath,
+            error instanceof Error ? error.name : typeof error
+          ]
+        });
+      }
+      throw error;
+    }
+  } finally {
+    process4.exit = originalExit;
+  }
+  if (finalExitCode !== 0) {
+    originalExit(finalExitCode);
+  }
+}
+if (import.meta.url === pathToFileURL(process4.argv[1]).href) {
+  void main(process4.argv.slice(2));
+}
+export {
+  main
+};
+//# sourceMappingURL=index.js.map