@canaryai/cli 0.1.6 → 0.1.11

package/dist/index.js

@@ -1,12 +1,1211 @@
-#!/usr/bin/env node
 import {
-  canary,
-  main,
-  run
-} from "./chunk-YA43CE6P.js";
-import "./chunk-Z6I3ZXZL.js";
-import "./chunk-UBYYNMML.js";
-import "./chunk-7OCVIDC7.js";
+  connectTunnel,
+  createLocalRun,
+  createTunnel,
+  runLocalTest,
+  runTunnel
+} from "./chunk-VYBCH4ZP.js";
+import {
+  ENV_URLS,
+  readStoredApiUrl,
+  readStoredAuth,
+  readStoredToken,
+  saveAuth
+} from "./chunk-HJ2JWIJ7.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// src/index.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import process7 from "process";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
+
+// src/runner/common.ts
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+function makeRequire() {
+  try {
+    return createRequire(import.meta.url);
+  } catch {
+    try {
+      return createRequire(process.cwd());
+    } catch {
+      return typeof __require !== "undefined" ? __require : createRequire(".");
+    }
+  }
+}
+function resolveRunner(preloadPath2) {
+  const { bin, version } = pickNodeBinary();
+  const supportsImport = typeof version === "number" && version >= 18;
+  if (supportsImport && preloadPath2 && fs.existsSync(preloadPath2)) {
+    return { runnerBin: bin, preloadFlag: `--import=${pathToFileURL(preloadPath2).href}` };
+  }
+  if (preloadPath2) {
+    console.warn("[canary] Warning: no preload module found; instrumentation may be disabled.");
+  }
+  return { runnerBin: bin };
+}
+function pickNodeBinary() {
+  const candidates = collectNodeCandidates();
+  let best;
+  let fallback;
+  for (const bin of candidates) {
+    const version = getNodeMajor(bin);
+    if (!version) continue;
+    const current = { bin, version };
+    if (version >= 18 && !fallback) {
+      fallback = current;
+    }
+    if (!best || version > (best.version ?? 0)) {
+      best = current;
+    }
+  }
+  if (fallback) return fallback;
+  if (best) return best;
+  return { bin: candidates[0] ?? "node" };
+}
+function collectNodeCandidates() {
+  const seen = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    if (!value) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+  };
+  const isBun = path.basename(process.execPath).includes("bun");
+  push(process.env.CANARY_NODE_BIN);
+  push(isBun ? void 0 : process.execPath);
+  push("node");
+  try {
+    const which = spawnSync("which", ["-a", "node"], { encoding: "utf-8" });
+    which.stdout?.toString().split("\n").map((line) => line.trim()).forEach((line) => push(line));
+  } catch {
+  }
+  const nvmDir = process.env.NVM_DIR || (process.env.HOME ? path.join(process.env.HOME, ".nvm") : void 0);
+  if (nvmDir) {
+    const versionsDir = path.join(nvmDir, "versions", "node");
+    if (fs.existsSync(versionsDir)) {
+      try {
+        const versions = fs.readdirSync(versionsDir);
+        versions.sort((a, b) => a > b ? -1 : 1).forEach((v) => push(path.join(versionsDir, v, "bin", "node")));
+      } catch {
+      }
+    }
+  }
+  return Array.from(seen);
+}
+function getNodeMajor(bin) {
+  try {
+    const result = spawnSync(bin, ["-v"], { encoding: "utf-8" });
+    const output = (result.stdout || result.stderr || "").toString().trim();
+    const match = output.match(/^v(\d+)/);
+    if (match) return Number(match[1]);
+  } catch {
+  }
+  return void 0;
+}
+
+// src/run.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { fileURLToPath } from "url";
+async function run(request = {}) {
+  const cwd = request.projectRoot ?? process.cwd();
+  const stdio = request.stdio ?? "inherit";
+  const requireFn2 = makeRequire();
+  const playwrightCli = requireFn2.resolve("@playwright/test/cli");
+  const baseDir2 = path2.dirname(fileURLToPath(import.meta.url));
+  const preloadPath2 = path2.join(baseDir2, "runner", "preload.js");
+  const { runnerBin, preloadFlag } = resolveRunner(preloadPath2);
+  const { jsonReportPath, eventLogPath, artifactsDir } = prepareArtifactsDir(cwd);
+  const reporter = buildReporterArgs(request.reporter, jsonReportPath);
+  const args = buildArgs({
+    testDir: request.testDir,
+    configFile: request.configFile,
+    cliArgs: request.cliArgs,
+    reporter
+  });
+  const nodeOptions = process.env.NODE_OPTIONS && preloadFlag ? `${process.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process.env.NODE_OPTIONS;
+  const env = buildEnv({
+    base: process.env,
+    overrides: request.env,
+    healing: request.healing,
+    eventLogPath,
+    nodeOptions
+  });
+  const runResult = await spawnPlaywright({
+    bin: request.nodeBin ?? runnerBin,
+    args: [playwrightCli, ...args],
+    cwd,
+    env,
+    stdio,
+    timeoutMs: request.timeoutMs
+  });
+  const summary = summarize(jsonReportPath, eventLogPath, runResult.durationMs);
+  return {
+    ok: runResult.exitCode === 0,
+    exitCode: runResult.exitCode,
+    summary,
+    artifactsDir,
+    rawOutput: runResult.output,
+    error: runResult.error
+  };
+}
+function buildArgs(opts) {
+  const args = ["test"];
+  if (opts.testDir) {
+    const dirs = Array.isArray(opts.testDir) ? opts.testDir : [opts.testDir];
+    args.push(...dirs);
+  }
+  if (opts.configFile) {
+    args.push("--config", opts.configFile);
+  }
+  args.push("--reporter", opts.reporter);
+  if (opts.cliArgs?.length) {
+    args.push(...opts.cliArgs);
+  }
+  return args;
+}
+function buildReporterArgs(requested, jsonReportPath) {
+  if (requested === "json") return `json=${jsonReportPath}`;
+  if (requested && requested !== "default") return requested;
+  return `list,json=${jsonReportPath}`;
+}
+function prepareArtifactsDir(cwd) {
+  const dir = fs2.mkdtempSync(path2.join(os.tmpdir(), "canary-run-"));
+  const jsonReportPath = path2.join(dir, "report.json");
+  const eventLogPath = path2.join(dir, "events-worker-0.jsonl");
+  const artifactsDir = path2.join(cwd, "test-results", "ai-healer");
+  return { jsonReportPath, eventLogPath, artifactsDir: dir };
+}
+function buildEnv(params) {
+  const healing = params.healing ?? {};
+  const env = {
+    ...params.base,
+    CANARY_ENABLED: params.base.CANARY_ENABLED ?? "1",
+    CANARY_RUNNER: "canary",
+    CANARY_EVENT_LOG: params.eventLogPath,
+    ...params.nodeOptions ? { NODE_OPTIONS: params.nodeOptions } : {},
+    ...healing.apiKey ? { AI_API_KEY: healing.apiKey } : {},
+    ...healing.provider ? { AI_PROVIDER: healing.provider } : {},
+    ...healing.model ? { AI_MODEL: healing.model } : {},
+    ...healing.timeoutMs ? { AI_TIMEOUT_MS: String(healing.timeoutMs) } : {},
+    ...healing.maxActions ? { CANARY_MAX_ACTIONS: String(healing.maxActions) } : {},
+    ...healing.vision ? { CANARY_VISION: "1" } : {},
+    ...healing.dryRun ? { CANARY_DRY_RUN: "1" } : {},
+    ...healing.warnOnly ? { CANARY_WARN_ONLY: "1" } : {},
+    ...healing.debug ? { CANARY_DEBUG: "1" } : {},
+    ...healing.readOnly ? { CANARY_READ_ONLY: "1" } : {},
+    ...healing.allowEvaluate === false ? { CANARY_ALLOW_EVALUATE: "0" } : {},
+    ...healing.allowRunCode ? { CANARY_ALLOW_RUN_CODE: "1" } : {},
+    ...healing.maxPayloadBytes ? { CANARY_MAX_PAYLOAD_BYTES: String(healing.maxPayloadBytes) } : {},
+    ...params.overrides
+  };
+  return env;
+}
+async function spawnPlaywright(opts) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const child = spawn(opts.bin, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: opts.stdio === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"]
+    });
+    let timer;
+    let output = "";
+    let error;
+    if (opts.stdio === "pipe") {
+      child.stdout?.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+    }
+    if (opts.timeoutMs && opts.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        error = new Error(`canary.run timed out after ${opts.timeoutMs}ms`);
+        child.kill("SIGKILL");
+      }, opts.timeoutMs);
+    }
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      resolve({ exitCode: code ?? 1, output: output || void 0, durationMs: Date.now() - started, error });
+    });
+  });
+}
+function summarize(jsonReportPath, eventLogPath, durationMs) {
+  const base = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    flaky: 0,
+    skipped: 0,
+    durationMs
+  };
+  const jsonReport = readJsonReport(jsonReportPath);
+  if (jsonReport) {
+    const counts = countTests(jsonReport);
+    base.total = counts.total;
+    base.passed = counts.passed;
+    base.failed = counts.failed;
+    base.flaky = counts.flaky;
+    base.skipped = counts.skipped;
+    base.durationMs = jsonReport.duration ?? durationMs;
+  }
+  const healed = countHealed(eventLogPath);
+  if (healed) {
+    return { ...base, healed };
+  }
+  return base;
+}
+function readJsonReport(reportPath) {
+  try {
+    if (fs2.existsSync(reportPath)) {
+      const raw = fs2.readFileSync(reportPath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function countTests(report) {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let flaky = 0;
+  let skipped = 0;
+  const visitSuite = (suite) => {
+    if (!suite) return;
+    suite.tests?.forEach((test) => {
+      total += 1;
+      const statuses = test.results.map((r) => r.status);
+      const hasFailed = statuses.includes("failed") || statuses.includes("interrupted");
+      const hasPassed = statuses.includes("passed");
+      const hasTimedOut = statuses.includes("timedOut");
+      const allSkipped = statuses.every((s) => s === "skipped");
+      if (allSkipped) {
+        skipped += 1;
+      } else if ((hasFailed || hasTimedOut) && hasPassed) {
+        flaky += 1;
+      } else if (hasFailed || hasTimedOut) {
+        failed += 1;
+      } else if (hasPassed && statuses.length > 1) {
+        flaky += 1;
+      } else if (hasPassed) {
+        passed += 1;
+      }
+    });
+    suite.suites?.forEach(visitSuite);
+  };
+  report.suites?.forEach(visitSuite);
+  return { total, passed, failed, flaky, skipped };
+}
+function countHealed(eventLogPath) {
+  try {
+    if (!fs2.existsSync(eventLogPath)) return void 0;
+    const raw = fs2.readFileSync(eventLogPath, "utf-8").trim();
+    if (!raw) return void 0;
+    const lines = raw.split("\n");
+    let healed = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        if (event?.healed === true) healed += 1;
+      } catch {
+      }
+    }
+    return healed;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/login.ts
+import process2 from "process";
+import readline from "readline";
+import { spawn as spawn2 } from "child_process";
+function envToProfile(env) {
+  if (env === "prod" || env === "production") return "production";
+  if (env === "dev") return "dev";
+  if (env === "local") return "local";
+  return env;
+}
+function getArgValue(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1) return void 0;
+  return argv[index + 1];
+}
+function shouldOpenBrowser(argv) {
+  return !argv.includes("--no-open");
+}
+function openUrl(url) {
+  const platform = process2.platform;
+  if (platform === "darwin") {
+    spawn2("open", [url], { stdio: "ignore" });
+    return;
+  }
+  if (platform === "win32") {
+    spawn2("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    return;
+  }
+  spawn2("xdg-open", [url], { stdio: "ignore" });
+}
+function promptChoice(question) {
+  const rl = readline.createInterface({ input: process2.stdin, output: process2.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function fetchOrgs(apiUrl, token) {
+  try {
+    const res = await fetch(`${apiUrl}/cli-login/orgs`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function switchOrg(apiUrl, token, orgId) {
+  const res = await fetch(`${apiUrl}/cli-login/switch-org`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ orgId })
+  });
+  return await res.json();
+}
+async function runLogin(argv) {
+  const env = getArgValue(argv, "--env");
+  const envUrls = env ? ENV_URLS[env] : void 0;
+  if (env && !envUrls) {
+    console.error(`Unknown environment: ${env}`);
+    console.error("Valid environments: prod, dev, local");
+    process2.exit(1);
+  }
+  const apiUrl = getArgValue(argv, "--api-url") ?? envUrls?.api ?? process2.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const appUrl = getArgValue(argv, "--app-url") ?? envUrls?.app ?? process2.env.CANARY_APP_URL ?? "https://app.trycanary.ai";
+  const orgFlag = getArgValue(argv, "--org");
+  const startRes = await fetch(`${apiUrl}/cli-login/start`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ appUrl })
+  });
+  const startJson = await startRes.json();
+  if (!startRes.ok || !startJson.ok || !startJson.deviceCode || !startJson.userCode) {
+    console.error("Login start failed", startJson.error ?? startRes.statusText);
+    process2.exit(1);
+  }
+  console.log("Login required.");
+  console.log(`User code: ${startJson.userCode}`);
+  if (startJson.verificationUrl) {
+    console.log(`Open: ${startJson.verificationUrl}`);
+    if (shouldOpenBrowser(argv)) {
+      try {
+        openUrl(startJson.verificationUrl);
+      } catch {
+        console.log("Unable to open browser automatically. Please open the URL manually.");
+      }
+    }
+  }
+  const intervalMs = (startJson.intervalSeconds ?? 3) * 1e3;
+  const expiresAt = startJson.expiresAt ? new Date(startJson.expiresAt).getTime() : null;
+  let token;
+  let initialOrgId;
+  while (true) {
+    if (expiresAt && Date.now() > expiresAt) {
+      console.error("Login code expired.");
+      process2.exit(1);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const pollRes = await fetch(`${apiUrl}/cli-login/poll`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ deviceCode: startJson.deviceCode })
+    });
+    const pollJson = await pollRes.json();
+    if (!pollRes.ok || !pollJson.ok) {
+      console.error("Login poll failed", pollJson.error ?? pollRes.statusText);
+      process2.exit(1);
+    }
+    if (pollJson.status === "approved" && pollJson.accessToken) {
+      token = pollJson.accessToken;
+      initialOrgId = pollJson.orgId;
+      break;
+    }
+    if (pollJson.status === "rejected") {
+      console.error("Login rejected.");
+      process2.exit(1);
+    }
+    if (pollJson.status === "expired") {
+      console.error("Login expired.");
+      process2.exit(1);
+    }
+  }
+  const orgsData = await fetchOrgs(apiUrl, token);
+  const orgs = orgsData?.organizations ?? [];
+  let finalToken = token;
+  let finalOrgId = initialOrgId;
+  let finalOrgName;
+  if (orgs.length <= 1) {
+    finalOrgName = orgs[0]?.name;
+  } else {
+    let selectedOrg;
+    if (orgFlag) {
+      selectedOrg = orgs.find(
+        (o) => o.name.toLowerCase() === orgFlag.toLowerCase() || o.id === orgFlag
+      );
+      if (!selectedOrg) {
+        console.error(`Organization "${orgFlag}" not found. Available orgs:`);
+        for (const o of orgs) {
+          console.error(`  - ${o.name} (${o.id})`);
+        }
+        process2.exit(1);
+      }
+    } else if (process2.stdin.isTTY) {
+      console.log("\nYou belong to multiple organizations. Select one:");
+      for (let i = 0; i < orgs.length; i++) {
+        const marker = orgs[i].id === initialOrgId ? " (current)" : "";
+        console.log(`  ${i + 1}. ${orgs[i].name}${marker}`);
+      }
+      const answer = await promptChoice(`
+Choice [1-${orgs.length}]: `);
+      const idx = parseInt(answer, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= orgs.length) {
+        console.error("Invalid selection.");
+        process2.exit(1);
+      }
+      selectedOrg = orgs[idx];
+    } else {
+      const defaultOrg = orgs.find((o) => o.id === initialOrgId);
+      console.log(
+        `Warning: Multiple organizations available but running non-interactively. Using "${defaultOrg?.name ?? initialOrgId}".`
+      );
+      console.log("Tip: Use --org <name> to select a specific organization.");
+      selectedOrg = defaultOrg;
+    }
+    if (selectedOrg && selectedOrg.id !== initialOrgId) {
+      const switchRes = await switchOrg(apiUrl, token, selectedOrg.id);
+      if (!switchRes.ok || !switchRes.accessToken) {
+        console.error("Failed to switch organization:", switchRes.error ?? "Unknown error");
+        process2.exit(1);
+      }
+      finalToken = switchRes.accessToken;
+      finalOrgId = switchRes.orgId;
+      finalOrgName = switchRes.orgName;
+    } else if (selectedOrg) {
+      finalOrgName = selectedOrg.name;
+    }
+  }
+  const profileName = env ? envToProfile(env) : void 0;
+  const filePath = await saveAuth({ token: finalToken, apiUrl, orgId: finalOrgId, orgName: finalOrgName }, profileName);
+  const displayName = finalOrgName ? ` to ${finalOrgName}` : "";
+  const profileLabel = profileName ? ` (profile: ${profileName})` : "";
+  console.log(`Login successful${displayName}${profileLabel}. Token saved to ${filePath}`);
+  console.log("Set CANARY_API_TOKEN to use the CLI without re-login.");
+}
+
+// src/orgs.ts
+import process3 from "process";
+async function runOrgs(argv) {
+  const token = process3.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    console.error("Not logged in. Run: canary login");
+    process3.exit(1);
+  }
+  const auth = await readStoredAuth();
+  const apiUrl = process3.env.CANARY_API_URL ?? auth?.apiUrl ?? "https://api.trycanary.ai";
+  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");
+    process3.exit(1);
+  }
+  const data = await res.json();
+  if (!data.ok || !data.organizations) {
+    console.error("Failed to fetch organizations:", data.error ?? "Unknown error");
+    process3.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})${marker}`);
+  }
+  console.log("\n* = current organization");
+  console.log("To switch: canary login --org <name>");
+}
+
+// src/run-local.ts
+import process4 from "process";
+function getArgValue2(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1) return void 0;
+  return argv[index + 1];
+}
+async function runLocalSession(argv) {
+  const apiUrl = getArgValue2(argv, "--api-url") ?? process4.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue2(argv, "--token") ?? process4.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+    process4.exit(1);
+  }
+  const portRaw = getArgValue2(argv, "--port") ?? process4.env.CANARY_LOCAL_PORT;
+  const tunnelUrl = getArgValue2(argv, "--tunnel-url");
+  const title = getArgValue2(argv, "--title");
+  const featureSpec = getArgValue2(argv, "--feature");
+  const startUrl = getArgValue2(argv, "--start-url");
+  if (!tunnelUrl && !portRaw) {
+    console.error("Missing --port or --tunnel-url");
+    process4.exit(1);
+  }
+  let publicUrl = tunnelUrl;
+  let ws = null;
+  if (!publicUrl && portRaw) {
+    const port = Number(portRaw);
+    if (Number.isNaN(port) || port <= 0) {
+      console.error("Invalid --port value");
+      process4.exit(1);
+    }
+    const tunnel = await createTunnel({ apiUrl, token, port });
+    publicUrl = tunnel.publicUrl;
+    ws = connectTunnel({
+      apiUrl,
+      tunnelId: tunnel.tunnelId,
+      token: tunnel.token,
+      port,
+      onReady: () => {
+        console.log(`Tunnel connected: ${publicUrl ?? tunnel.tunnelId}`);
+      }
+    });
+  }
+  if (!publicUrl) {
+    console.error("Failed to resolve tunnel URL");
+    process4.exit(1);
+  }
+  const run2 = await createLocalRun({
+    apiUrl,
+    token,
+    title,
+    featureSpec,
+    startUrl,
+    tunnelUrl: publicUrl
+  });
+  console.log(`Local test queued: ${run2.runId}`);
+  if (run2.watchUrl) {
+    console.log(`Watch: ${run2.watchUrl}`);
+  }
+  if (ws) {
+    console.log("Tunnel active. Press Ctrl+C to stop.");
+    process4.on("SIGINT", () => {
+      ws?.close();
+      process4.exit(0);
+    });
+    await new Promise(() => void 0);
+  }
+}
+
+// src/remote-test.ts
+import process5 from "process";
+import { createParser } from "eventsource-parser";
+function getArgValue3(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1 || index >= argv.length - 1) return void 0;
+  return argv[index + 1];
+}
+function hasFlag(argv, ...flags) {
+  return flags.some((flag) => argv.includes(flag));
+}
+function formatFailedTests(failedTests, appUrl) {
+  if (failedTests.length === 0 || !appUrl) return null;
+  const lines = ["", "Failed tests:"];
+  for (const t of failedTests) {
+    lines.push(`  \u2717 ${t.name}`);
+    lines.push(`    ${appUrl}/runs/tests/${t.testRunId}`);
+  }
+  return lines.join("\n");
+}
+async function runRemoteTest(argv) {
+  const apiUrl = getArgValue3(argv, "--api-url") ?? process5.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue3(argv, "--token") ?? process5.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const tag = getArgValue3(argv, "--tag");
+  const namePattern = getArgValue3(argv, "--name-pattern");
+  const verbose = hasFlag(argv, "--verbose", "-v");
+  if (!token) {
+    console.error("Error: No API token found.");
+    console.error("");
+    console.error("Set CANARY_API_TOKEN environment variable or run:");
+    console.error("  canary login");
+    console.error("");
+    console.error("Or create an API key in Settings > API Keys and pass it:");
+    console.error("  canary test --remote --token cnry_...");
+    process5.exit(1);
+  }
+  console.log("Starting remote workflow tests...");
+  if (tag) console.log(`  Filtering by tag: ${tag}`);
+  if (namePattern) console.log(`  Filtering by name pattern: ${namePattern}`);
+  console.log("");
+  const queryParams = new URLSearchParams();
+  if (tag) queryParams.set("tag", tag);
+  if (namePattern) queryParams.set("namePattern", namePattern);
+  const triggerUrl = `${apiUrl}/workflows/test-runs${queryParams.toString() ? `?${queryParams}` : ""}`;
+  let triggerRes;
+  try {
+    triggerRes = await fetch(triggerUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+  } catch (err) {
+    console.error(`Failed to connect to API: ${err}`);
+    process5.exit(1);
+  }
+  if (!triggerRes.ok) {
+    const errorText = await triggerRes.text();
+    console.error(`Failed to start tests: ${triggerRes.status}`);
+    console.error(errorText);
+    process5.exit(1);
+  }
+  const triggerData = await triggerRes.json();
+  if (!triggerData.ok || !triggerData.suiteId) {
+    console.error(`Failed to start tests: ${triggerData.error ?? "Unknown error"}`);
+    process5.exit(1);
+  }
+  const { suiteId, jobId, appUrl } = triggerData;
+  if (verbose) {
+    console.log(`Suite ID: ${suiteId}`);
+    console.log(`Job ID: ${jobId}`);
+    console.log("");
+  }
+  const streamUrl = `${apiUrl}/workflows/test-runs/stream?suiteId=${suiteId}`;
+  let streamRes;
+  try {
+    streamRes = await fetch(streamUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "text/event-stream"
+      }
+    });
+  } catch (err) {
+    console.error(`Failed to connect to event stream: ${err}`);
+    process5.exit(1);
+  }
+  if (!streamRes.ok || !streamRes.body) {
+    console.error(`Failed to connect to event stream: ${streamRes.status}`);
+    process5.exit(1);
+  }
+  let exitCode = 0;
+  let hasCompleted = false;
+  const workflowNames = /* @__PURE__ */ new Map();
+  const failedTests = [];
+  let totalWorkflows = 0;
+  let completedWorkflows = 0;
+  let failedWorkflows = 0;
+  let successfulWorkflows = 0;
+  const parser = createParser({
+    onEvent: (event) => {
+      if (!event.data) return;
+      try {
+        const data = JSON.parse(event.data);
+        if (verbose) {
+          console.log(`[${event.event}] ${JSON.stringify(data)}`);
+        }
+        if (event.event === "workflow-test") {
+          const testEvent = data;
+          const { status, workflowId, message, errorMessage } = testEvent;
+          const name = workflowNames.get(workflowId) || message?.replace(/^Flow "(.+)" .*$/, "$1") || workflowId;
+          if (message?.startsWith('Flow "')) {
+            const match = message.match(/^Flow "(.+?)" /);
+            if (match) workflowNames.set(workflowId, match[1]);
+          }
+          if (!verbose) {
+            if (status === "success") {
+              console.log(`  \u2713 ${name}`);
+            } else if (status === "failed") {
+              console.log(`  \u2717 ${name}`);
+              if (errorMessage) {
+                console.log(`    Error: ${errorMessage.slice(0, 200)}`);
+              }
+              failedTests.push({ name, testRunId: testEvent.testRunId });
+              exitCode = 1;
+            } else if (status === "running") {
+            } else if (status === "waiting") {
+              console.log(`  \u23F3 ${name} (waiting for scheduled time)`);
+            }
+          }
+        }
+        if (event.event === "workflow-test-suite") {
+          const suiteEvent = data;
+          totalWorkflows = suiteEvent.totalWorkflows;
+          completedWorkflows = suiteEvent.completedWorkflows;
+          failedWorkflows = suiteEvent.failedWorkflows;
+          successfulWorkflows = suiteEvent.successfulWorkflows;
+          if (suiteEvent.status === "completed") {
+            hasCompleted = true;
+          }
+        }
+        if (event.event === "error") {
+          const errorData = data;
+          console.error(`Stream error: ${errorData.error ?? "Unknown error"}`);
+          exitCode = 1;
+        }
+      } catch {
+      }
+    }
+  });
+  const reader = streamRes.body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    while (!hasCompleted) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      parser.feed(decoder.decode(value, { stream: true }));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  console.log("");
+  console.log("\u2500".repeat(50));
+  if (totalWorkflows === 0) {
+    console.log("No workflows found matching the filter criteria.");
+    process5.exit(0);
+  }
+  const passRate = totalWorkflows > 0 ? Math.round(successfulWorkflows / totalWorkflows * 100) : 0;
+  if (failedWorkflows > 0) {
+    console.log(`FAILED: ${failedWorkflows} of ${totalWorkflows} workflows failed (${passRate}% pass rate)`);
+    exitCode = 1;
+  } else {
+    console.log(`PASSED: ${successfulWorkflows} of ${totalWorkflows} workflows passed`);
+  }
+  const waitingWorkflows = totalWorkflows - completedWorkflows;
+  if (waitingWorkflows > 0) {
+    console.log(`Note: ${waitingWorkflows} workflow(s) are still waiting (scheduled for later)`);
+  }
+  const failedSection = formatFailedTests(failedTests, appUrl);
+  if (failedSection) {
+    console.log(failedSection);
+  }
+  process5.exit(exitCode);
+}
+
+// src/debug-session.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+import process6 from "process";
+var ENV_URLS2 = {
+  prod: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  production: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  dev: {
+    api: "https://api.dev.trycanary.ai",
+    app: "https://app.dev.trycanary.ai"
+  },
+  local: {
+    api: "http://localhost:3000",
+    app: "http://localhost:5173"
+  }
+};
+function getArgValue4(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1 || index >= argv.length - 1) return void 0;
+  return argv[index + 1];
+}
+function hasFlag2(argv, ...flags) {
+  return flags.some((flag) => argv.includes(flag));
+}
+async function writeDebugSession(loginUrl, expiresAt, apiUrl) {
+  const dir = path3.join(os2.homedir(), ".config", "canary-cli");
+  const filePath = path3.join(dir, "debug-session.json");
+  await fs3.mkdir(dir, { recursive: true, mode: 448 });
+  await fs3.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 env = getArgValue4(argv, "--env");
+  const envUrls = env ? ENV_URLS2[env] : void 0;
+  if (env && !envUrls) {
+    console.error(`Unknown environment: ${env}`);
+    console.error("Valid environments: prod, dev, local");
+    process6.exit(1);
+  }
+  const storedApiUrl = await readStoredApiUrl();
+  const apiUrl = getArgValue4(argv, "--api-url") ?? envUrls?.api ?? process6.env.CANARY_API_URL ?? storedApiUrl ?? "https://api.trycanary.ai";
+  const token = getArgValue4(argv, "--token") ?? process6.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const jsonOutput = hasFlag2(argv, "--json");
+  if (!token) {
+    console.error("Error: No API token found.");
+    console.error("Run: canary login [--env <env>]");
+    process6.exit(1);
+  }
+  try {
+    const res = await fetch(`${apiUrl}/auth/debug-session/create`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      if (res.status === 401) {
+        console.error("Error: Unauthorized. Your session may have expired.");
+        console.error("Run: canary login");
+        process6.exit(1);
+      }
+      if (res.status === 403) {
+        console.error("Error: Forbidden. Debug session creation requires superadmin access.");
+        process6.exit(1);
+      }
+      if (res.status === 404) {
+        console.error(
+          "Error: Endpoint not found. The debug-session feature may not be deployed to this environment."
+        );
+        process6.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}`);
+      }
+      process6.exit(1);
+    }
+    const json = await res.json();
+    if (!json.ok || !json.loginUrl) {
+      console.error(`Error: ${json.message ?? json.error ?? "Failed to create debug session"}`);
+      process6.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}`);
+    process6.exit(1);
+  }
+}
+
+// src/jwt.ts
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const json = Buffer.from(base64, "base64").toString("utf8");
+    const payload = JSON.parse(json);
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+      return null;
+    }
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function isSuperadminToken(token) {
+  if (!token) return false;
+  const payload = decodeJwtPayload(token);
+  return payload?.is_superadmin === true;
+}
+
+// src/index.ts
+var require2 = createRequire2(import.meta.url);
+var pkg = require2("../package.json");
+var loadMcp = () => import("./mcp-I6FCGDDR.js").then((m) => m.runMcp);
+var loadLocalBrowser = () => import("./local-browser-VOBIUIGT.js").then((m) => m.runLocalBrowser);
+var canary = { run };
+var baseDir = typeof __dirname !== "undefined" ? __dirname : path4.dirname(fileURLToPath2(import.meta.url));
+var preloadPath = path4.join(baseDir, "runner", "preload.js");
+var requireFn = makeRequire();
+function runPlaywrightTests(args) {
+  const playwrightCli = requireFn.resolve("@playwright/test/cli");
+  const { runnerBin, preloadFlag } = resolveRunner(preloadPath);
+  const nodeOptions = process7.env.NODE_OPTIONS && preloadFlag ? `${process7.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process7.env.NODE_OPTIONS;
+  const env = {
+    ...process7.env,
+    CANARY_ENABLED: process7.env.CANARY_ENABLED ?? "1",
+    CANARY_RUNNER: "canary",
+    ...nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}
+  };
+  const result = spawnSync2(runnerBin, [playwrightCli, "test", ...args], {
+    env,
+    stdio: "inherit",
+    cwd: process7.cwd()
+  });
+  if (result.error) {
+    console.error("canary failed to launch Playwright:", result.error);
+    process7.exit(1);
+  }
+  process7.exit(result.status ?? 1);
+}
+function printVersion() {
+  console.log(`canary v${pkg.version}`);
+}
+function printHelp({ isSuperadmin }) {
+  const lines = [
+    `canary v${pkg.version}: Local and remote testing CLI`,
+    "",
+    "Usage:",
+    "  canary test [playwright options]        Run local Playwright tests",
+    "  canary test --remote [options]          Run remote workflow tests",
+    "  canary local-run --tunnel-url <url> [options]",
+    "  canary tunnel --port <localPort> [options]",
+    "  canary run --port <localPort> [options]",
+    "  canary mcp",
+    "  canary browser [--mode playwright|cdp] [--cdp-url <url>] [--no-headless]",
+    "  canary login [--org <name>] [--app-url https://app.trycanary.ai] [--no-open]",
+    "  canary orgs                            List organizations"
+  ];
+  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 feature-flag <sub-command>       Manage feature flags",
+      "  canary knobs <sub-command>              Manage knobs (global config)"
+    );
+  }
+  lines.push(
+    "  canary version                          Show version",
+    "  canary help",
+    "",
+    "Remote test options:",
+    "  --token <key>         API key (or set CANARY_API_TOKEN)",
+    "  --api-url <url>       API URL (default: https://api.trycanary.ai)",
+    "  --tag <tag>           Filter workflows by tag",
+    "  --name-pattern <pat>  Filter workflows by name pattern",
+    "  --verbose, -v         Show all events",
+    "",
+    "Browser options:",
+    "  --mode <playwright|cdp>  Browser mode (default: playwright)",
+    "  --cdp-url <url>          CDP endpoint for existing Chrome",
+    "  --no-headless            Run browser with visible UI",
+    "  --storage-state <path>   Path to storage state JSON",
+    "  --instructions <text>    Instructions for the cloud agent",
+    "",
+    "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"
+  );
+  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",
+      "",
+      "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"
+    );
+  }
+  lines.push(
+    "",
+    "Flags:",
+    "  -h, --help     Show help",
+    "  -V, --version  Show version"
+  );
+  console.log(lines.join("\n"));
+}
+function printTestHelp() {
+  console.log(
+    [
+      `canary v${pkg.version}: Test command`,
+      "",
+      "Usage:",
+      "  canary test [playwright options]        Run local Playwright tests",
+      "  canary test --remote [options]          Run remote workflow tests",
+      "",
+      "Local Playwright options (passed through to Playwright):",
+      "  --grep <pattern>       Only run tests matching pattern",
+      "  --headed               Run in headed browser mode",
+      "  --workers <n>          Number of parallel workers",
+      "  --project <name>       Run specific project",
+      "  --reporter <reporter>  Use a specific reporter",
+      "  --retries <n>          Number of retries for failed tests",
+      "  --timeout <ms>         Test timeout in milliseconds",
+      "",
+      "Remote test options:",
+      "  --remote               Run tests remotely (required)",
+      "  --token <key>          API key (or set CANARY_API_TOKEN)",
+      "  --api-url <url>        API URL (default: https://api.trycanary.ai)",
+      "  --tag <tag>            Filter workflows by tag",
+      "  --name-pattern <pat>   Filter workflows by name pattern",
+      "  --verbose, -v          Show all events",
+      "",
+      "Examples:",
+      "  canary test                             Run all local tests",
+      '  canary test --grep "login"              Run tests matching "login"',
+      "  canary test --headed --workers 1        Debug with visible browser",
+      "  canary test --remote --tag smoke        Run remote smoke tests"
+    ].join("\n")
+  );
+}
+var COMMANDS_WITH_HELP = /* @__PURE__ */ new Set(["test"]);
+async function resolveToken() {
+  return process7.env.CANARY_API_TOKEN ?? await readStoredToken();
+}
+async function main(argv) {
+  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))) {
+    const token2 = await resolveToken();
+    printHelp({ isSuperadmin: isSuperadminToken(token2) });
+    return;
+  }
+  if (!command || command === "help") {
+    const token2 = await resolveToken();
+    printHelp({ isSuperadmin: isSuperadminToken(token2) });
+    return;
+  }
+  if (command === "version") {
+    printVersion();
+    return;
+  }
+  if (command === "test") {
+    if (rest.includes("--help") || rest.includes("-h")) {
+      printTestHelp();
+      return;
+    }
+    if (rest.includes("--remote")) {
+      const remoteArgs = rest.filter((arg) => arg !== "--remote");
+      await runRemoteTest(remoteArgs);
+      return;
+    }
+    runPlaywrightTests(rest);
+    return;
+  }
+  if (command === "local-run") {
+    await runLocalTest(rest);
+    return;
+  }
+  if (command === "run") {
+    await runLocalSession(rest);
+    return;
+  }
+  if (command === "mcp") {
+    const runMcp = await loadMcp();
+    await runMcp(rest);
+    return;
+  }
+  if (command === "tunnel") {
+    await runTunnel(rest);
+    return;
+  }
+  if (command === "login") {
+    await runLogin(rest);
+    return;
+  }
+  if (command === "orgs") {
+    await runOrgs(rest);
+    return;
+  }
+  if (command === "browser") {
+    const runLocalBrowser = await loadLocalBrowser();
+    await runLocalBrowser(rest);
+    return;
+  }
+  if (command === "debug-session") {
+    await runDebugSession(rest);
+    return;
+  }
+  if (command === "psql") {
+    const { runPsql } = await import("./psql-A3BADRQN.js");
+    await runPsql(rest);
+    return;
+  }
+  if (command === "redis") {
+    const { runRedis } = await import("./redis-N2DSDDQU.js");
+    await runRedis(rest);
+    return;
+  }
+  if (command === "feature-flag") {
+    const { runFeatureFlag } = await import("./feature-flag-PN5IFFQR.js");
+    await runFeatureFlag(rest);
+    return;
+  }
+  if (command === "knobs") {
+    const { runKnobs } = await import("./knobs-DAG7HD2F.js");
+    await runKnobs(rest);
+    return;
+  }
+  console.log(`Unknown command "${command}".`);
+  const token = await resolveToken();
+  printHelp({ isSuperadmin: isSuperadminToken(token) });
+  process7.exit(1);
+}
+if (import.meta.url === pathToFileURL2(process7.argv[1]).href) {
+  void main(process7.argv.slice(2));
+}
 export {
   canary,
   main,