@canaryai/cli 0.1.1-alpha.0

package/dist/index.js

@@ -0,0 +1,916 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import process7 from "process";
+import path5 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/local-run.ts
+import process2 from "process";
+
+// src/auth.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+async function readStoredToken() {
+  try {
+    const filePath = path3.join(os2.homedir(), ".config", "canary-cli", "auth.json");
+    const content = await fs3.readFile(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    return typeof parsed.token === "string" ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/local-run.ts
+function getArgValue(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1) return void 0;
+  return argv[index + 1];
+}
+async function runLocalTest(argv) {
+  const apiUrl = getArgValue(argv, "--api-url") ?? process2.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue(argv, "--token") ?? process2.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const title = getArgValue(argv, "--title");
+  const featureSpec = getArgValue(argv, "--feature");
+  const startUrl = getArgValue(argv, "--start-url");
+  const tunnelUrl = getArgValue(argv, "--tunnel-url");
+  if (!tunnelUrl && !startUrl) {
+    console.error("Missing --tunnel-url or --start-url");
+    process2.exit(1);
+  }
+  if (!token) {
+    console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+    process2.exit(1);
+  }
+  const result = await createLocalRun({
+    apiUrl,
+    token,
+    title,
+    featureSpec,
+    startUrl,
+    tunnelUrl
+  });
+  console.log(`Local test queued: ${result.runId}`);
+  if (result.watchUrl) {
+    console.log(`Watch: ${result.watchUrl}`);
+  }
+}
+async function createLocalRun(input) {
+  const body = {
+    title: input.title ?? null,
+    featureSpec: input.featureSpec ?? null,
+    startUrl: input.startUrl ?? null,
+    tunnelPublicUrl: input.tunnelUrl ?? null
+  };
+  const response = await fetch(`${input.apiUrl}/local-tests/runs`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${input.token}`
+    },
+    body: JSON.stringify(body)
+  });
+  const json = await response.json();
+  if (!response.ok || !json.ok || !json.runId) {
+    throw new Error(json.error ?? response.statusText);
+  }
+  return { runId: json.runId, watchUrl: json.watchUrl };
+}
+
+// src/tunnel.ts
+import { createHash } from "crypto";
+import os3 from "os";
+import process3 from "process";
+function getArgValue2(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1) return void 0;
+  return argv[index + 1];
+}
+function toWebSocketUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+function createFingerprint() {
+  const raw = `${os3.hostname()}-${os3.userInfo().username}-${process3.version}`;
+  return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+async function runTunnel(argv) {
+  const apiUrl = getArgValue2(argv, "--api-url") ?? process3.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue2(argv, "--token") ?? process3.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const portRaw = getArgValue2(argv, "--port") ?? process3.env.CANARY_LOCAL_PORT;
+  if (!portRaw) {
+    console.error("Missing --port");
+    process3.exit(1);
+  }
+  const port = Number(portRaw);
+  if (Number.isNaN(port) || port <= 0) {
+    console.error("Invalid --port value");
+    process3.exit(1);
+  }
+  if (!token) {
+    console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+    process3.exit(1);
+  }
+  const data = await createTunnel({
+    apiUrl,
+    token,
+    port
+  });
+  const ws = connectTunnel({
+    apiUrl,
+    tunnelId: data.tunnelId,
+    token: data.token,
+    port
+  });
+  ws.onopen = () => {
+    console.log(`Tunnel connected: ${data.publicUrl ?? data.tunnelId}`);
+    if (data.publicUrl) {
+      console.log(`Public URL: ${data.publicUrl}`);
+    }
+  };
+  await new Promise(() => void 0);
+}
+async function createTunnel(input) {
+  const response = await fetch(`${input.apiUrl}/local-tests/tunnels`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${input.token}`
+    },
+    body: JSON.stringify({
+      requestedPort: input.port,
+      clientFingerprint: createFingerprint()
+    })
+  });
+  const data = await response.json();
+  if (!response.ok || !data.ok || !data.tunnelId || !data.token) {
+    throw new Error(data.error ?? response.statusText);
+  }
+  return { tunnelId: data.tunnelId, publicUrl: data.publicUrl, token: data.token };
+}
+function connectTunnel(input) {
+  const wsUrl = toWebSocketUrl(
+    `${input.apiUrl}/local-tests/tunnels/${input.tunnelId}/connect?token=${input.token}`
+  );
+  const ws = new WebSocket(wsUrl);
+  ws.onopen = () => {
+    input.onReady?.();
+  };
+  ws.onerror = (event) => {
+    console.error("Tunnel error", event);
+  };
+  ws.onclose = () => {
+    console.log("Tunnel closed");
+  };
+  ws.onmessage = async (event) => {
+    try {
+      const raw = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString();
+      const payload = JSON.parse(raw);
+      if (payload.type === "http_request") {
+        const request = payload;
+        const targetUrl = `http://localhost:${input.port}${request.path.startsWith("/") ? request.path : `/${request.path}`}`;
+        const body = request.bodyBase64 ? Buffer.from(request.bodyBase64, "base64") : void 0;
+        const headers = { ...request.headers };
+        delete headers.host;
+        delete headers["content-length"];
+        try {
+          const res = await fetch(targetUrl, {
+            method: request.method,
+            headers,
+            body: body ?? void 0
+          });
+          const resBody = await res.arrayBuffer();
+          const responsePayload = {
+            type: "http_response",
+            id: request.id,
+            status: res.status,
+            headers: Object.fromEntries(res.headers.entries()),
+            bodyBase64: resBody.byteLength ? Buffer.from(resBody).toString("base64") : null
+          };
+          ws.send(JSON.stringify(responsePayload));
+        } catch (error) {
+          const responsePayload = {
+            type: "http_response",
+            id: request.id,
+            status: 502,
+            headers: { "content-type": "text/plain" },
+            bodyBase64: Buffer.from(`Tunnel error: ${String(error)}`).toString("base64")
+          };
+          ws.send(JSON.stringify(responsePayload));
+        }
+      }
+      if (payload.type === "health_ping") {
+        ws.send(JSON.stringify({ type: "health_pong" }));
+      }
+    } catch (error) {
+      console.error("Tunnel message error", error);
+    }
+  };
+  return ws;
+}
+
+// src/login.ts
+import fs4 from "fs/promises";
+import os4 from "os";
+import path4 from "path";
+import process4 from "process";
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_APP_URL = "https://app.trycanary.ai";
+function getArgValue3(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 = process4.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" });
+}
+async function writeToken(token) {
+  const dir = path4.join(os4.homedir(), ".config", "canary-cli");
+  const filePath = path4.join(dir, "auth.json");
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(filePath, JSON.stringify({ token }, null, 2), "utf8");
+  return filePath;
+}
+async function runLogin(argv) {
+  const apiUrl = getArgValue3(argv, "--api-url") ?? process4.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const appUrl = getArgValue3(argv, "--app-url") ?? process4.env.CANARY_APP_URL ?? DEFAULT_APP_URL;
+  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);
+    process4.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;
+  while (true) {
+    if (expiresAt && Date.now() > expiresAt) {
+      console.error("Login code expired.");
+      process4.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);
+      process4.exit(1);
+    }
+    if (pollJson.status === "approved" && pollJson.accessToken) {
+      const filePath = await writeToken(pollJson.accessToken);
+      console.log(`Login successful. Token saved to ${filePath}`);
+      console.log("Set CANARY_API_TOKEN to use the CLI without re-login.");
+      return;
+    }
+    if (pollJson.status === "rejected") {
+      console.error("Login rejected.");
+      process4.exit(1);
+    }
+    if (pollJson.status === "expired") {
+      console.error("Login expired.");
+      process4.exit(1);
+    }
+  }
+}
+
+// src/run-local.ts
+import process5 from "process";
+function getArgValue4(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1) return void 0;
+  return argv[index + 1];
+}
+async function runLocalSession(argv) {
+  const apiUrl = getArgValue4(argv, "--api-url") ?? process5.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue4(argv, "--token") ?? process5.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+    process5.exit(1);
+  }
+  const portRaw = getArgValue4(argv, "--port") ?? process5.env.CANARY_LOCAL_PORT;
+  const tunnelUrl = getArgValue4(argv, "--tunnel-url");
+  const title = getArgValue4(argv, "--title");
+  const featureSpec = getArgValue4(argv, "--feature");
+  const startUrl = getArgValue4(argv, "--start-url");
+  if (!tunnelUrl && !portRaw) {
+    console.error("Missing --port or --tunnel-url");
+    process5.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");
+      process5.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");
+    process5.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.");
+    process5.on("SIGINT", () => {
+      ws?.close();
+      process5.exit(0);
+    });
+    await new Promise(() => void 0);
+  }
+}
+
+// src/mcp.ts
+import process6 from "process";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { createParser } from "eventsource-parser";
+var DEFAULT_API_URL = "https://api.trycanary.ai";
+function resolveApiUrl(input) {
+  return input ?? process6.env.CANARY_API_URL ?? DEFAULT_API_URL;
+}
+async function resolveToken() {
+  const token = process6.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    throw new Error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
+  }
+  return token;
+}
+function toolText(text) {
+  return { content: [{ type: "text", text }] };
+}
+function toolJson(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+async function runMcp(argv) {
+  const server = new Server(
+    { name: "canary-cli", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "local_run_tests",
+        description: "Start an async local test run. A tunnel is opened automatically. Returns runId and watchUrl.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            port: { type: "number" },
+            instructions: { type: "string" },
+            title: { type: "string" }
+          },
+          required: ["port", "instructions"]
+        }
+      },
+      {
+        name: "local_wait_for_results",
+        description: "Wait for a local test run to complete. Streams until completion and returns a compact report.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            runId: { type: "string" }
+          },
+          required: ["runId"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const token = await resolveToken();
+    const tool = req.params.name;
+    if (tool === "local_run_tests") {
+      const input = req.params.arguments;
+      const apiUrl = resolveApiUrl();
+      const tunnel = await createTunnel({ apiUrl, token, port: input.port });
+      connectTunnel({
+        apiUrl,
+        tunnelId: tunnel.tunnelId,
+        token: tunnel.token,
+        port: input.port
+      });
+      const tunnelUrl = tunnel.publicUrl;
+      const run2 = await createLocalRun({
+        apiUrl,
+        token,
+        title: input.title ?? "Local MCP run",
+        featureSpec: input.instructions,
+        startUrl: null,
+        tunnelUrl
+      });
+      return toolJson({
+        runId: run2.runId,
+        watchUrl: run2.watchUrl,
+        tunnelUrl,
+        note: "Testing is asynchronous. Use local_wait_for_results with the runId to wait for completion."
+      });
+    }
+    if (tool === "local_wait_for_results") {
+      const input = req.params.arguments;
+      const apiUrl = resolveApiUrl();
+      const report = await waitForResult({ apiUrl, token, runId: input.runId });
+      return toolJson(report);
+    }
+    return toolText(`Unknown tool: ${tool}`);
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  return new Promise(() => void 0);
+}
+async function waitForResult(input) {
+  await streamUntilComplete(input);
+  const response = await fetch(`${input.apiUrl}/local-tests/runs/${input.runId}`, {
+    credentials: "include",
+    headers: { authorization: `Bearer ${input.token}` }
+  });
+  const data = await response.json();
+  const run2 = data?.data?.run ?? data?.run ?? data?.data;
+  const summary = run2?.summaryJson;
+  return formatReport({ run: run2, summary });
+}
+async function streamUntilComplete(input) {
+  const response = await fetch(`${input.apiUrl}/local-tests/runs/${input.runId}/stream`, {
+    headers: { authorization: `Bearer ${input.token}` }
+  });
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    if (event.event === "status") {
+      try {
+        const payload = JSON.parse(event.data);
+        if (payload?.status === "completed" || payload?.status === "failed") {
+          reader.cancel().catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+    if (event.event === "complete" || event.event === "error") {
+      reader.cancel().catch(() => void 0);
+    }
+  });
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value, { stream: true }));
+  }
+}
+function formatReport(input) {
+  if (!input.summary) {
+    return {
+      runId: input.run?.id,
+      status: input.run?.status ?? "unknown",
+      summary: "No final report available."
+    };
+  }
+  const tested = Array.isArray(input.summary.testedItems) ? input.summary.testedItems : [];
+  const status = input.summary.status ?? input.run?.status ?? "unknown";
+  const issues = status === "issues_found" ? input.summary.notes ? [input.summary.notes] : ["Issues reported."] : [];
+  return {
+    runId: input.run?.id,
+    status,
+    summary: input.summary.summary ?? "Run completed.",
+    testedItems: tested,
+    issues,
+    notes: input.summary.notes ?? null
+  };
+}
+
+// src/index.ts
+var canary = { run };
+var baseDir = typeof __dirname !== "undefined" ? __dirname : path5.dirname(fileURLToPath2(import.meta.url));
+var preloadPath = path5.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);
+}
+async function main(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      "canary: Playwright AI healer runner (scaffold).\nUsage: canary test [playwright options]\n       canary local-run --tunnel-url <url> [options]\n       canary tunnel --port <localPort> [options]\n       canary run --port <localPort> [options]\n       canary mcp\n       canary login [--app-url https://app.trycanary.ai] [--api-url http://localhost:3000] [--no-open]\nPlan: see ai-healer-runner-plan.md"
+    );
+    return;
+  }
+  const [command, ...rest] = argv;
+  if (!command || command === "test") {
+    runPlaywrightTests(rest);
+    return;
+  }
+  if (command === "local-run") {
+    await runLocalTest(rest);
+    return;
+  }
+  if (command === "run") {
+    await runLocalSession(rest);
+    return;
+  }
+  if (command === "mcp") {
+    await runMcp(rest);
+    return;
+  }
+  if (command === "tunnel") {
+    await runTunnel(rest);
+    return;
+  }
+  if (command === "login") {
+    await runLogin(rest);
+    return;
+  }
+  console.log(`Unknown command "${command}". Try "canary test" or "--help".`);
+  process7.exit(1);
+}
+if (import.meta.url === pathToFileURL2(process7.argv[1]).href) {
+  void main(process7.argv.slice(2));
+}
+export {
+  canary,
+  main,
+  run
+};
+//# sourceMappingURL=index.js.map