@canaryai/cli 0.1.4 → 0.1.6

package/dist/bin.js

@@ -1,2059 +1,10 @@
 #!/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 process9 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";
-
-// 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 maxReconnectAttempts = 10;
-  const baseReconnectDelayMs = 1e3;
-  let reconnectAttempts = 0;
-  const connect = async () => {
-    try {
-      const data = await createTunnel({
-        apiUrl,
-        token,
-        port
-      });
-      console.log(`Tunnel connected: ${data.publicUrl ?? data.tunnelId}`);
-      if (data.publicUrl) {
-        console.log(`Public URL: ${data.publicUrl}`);
-        console.log("");
-        console.log("To use this tunnel for sandbox agent callbacks, add to apps/api/.env:");
-        console.log(`  SANDBOX_AGENT_API_URL=${data.publicUrl}`);
-        console.log("");
-      }
-      const ws = connectTunnel({
-        apiUrl,
-        tunnelId: data.tunnelId,
-        token: data.token,
-        port,
-        onReady: () => {
-          reconnectAttempts = 0;
-        }
-      });
-      return new Promise((resolve, reject) => {
-        ws.onclose = (event) => {
-          console.log(`Tunnel closed (code: ${event.code})`);
-          if (reconnectAttempts < maxReconnectAttempts) {
-            const delay = Math.min(baseReconnectDelayMs * Math.pow(2, reconnectAttempts), 3e4);
-            reconnectAttempts++;
-            console.log(`Reconnecting in ${delay}ms (attempt ${reconnectAttempts}/${maxReconnectAttempts})...`);
-            setTimeout(() => {
-              connect().then(resolve).catch(reject);
-            }, delay);
-          } else {
-            console.error("Max reconnection attempts reached. Exiting.");
-            process3.exit(1);
-          }
-        };
-        ws.onerror = (event) => {
-          console.error("Tunnel error:", event);
-        };
-      });
-    } catch (error) {
-      if (reconnectAttempts < maxReconnectAttempts) {
-        const delay = Math.min(baseReconnectDelayMs * Math.pow(2, reconnectAttempts), 3e4);
-        reconnectAttempts++;
-        console.error(`Failed to create tunnel: ${error}`);
-        console.log(`Retrying in ${delay}ms (attempt ${reconnectAttempts}/${maxReconnectAttempts})...`);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return connect();
-      } else {
-        console.error("Max reconnection attempts reached. Exiting.");
-        process3.exit(1);
-      }
-    }
-  };
-  await connect();
-}
-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);
-  const wsConnections = /* @__PURE__ */ new Map();
-  const wsQueues = /* @__PURE__ */ new Map();
-  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 resHeaders = Object.fromEntries(res.headers.entries());
-          delete resHeaders["set-cookie"];
-          const getSetCookie = res.headers.getSetCookie;
-          const setCookieValues = typeof getSetCookie === "function" ? getSetCookie.call(res.headers) : [];
-          const fallbackSetCookie = res.headers.get("set-cookie");
-          if (setCookieValues.length === 0 && fallbackSetCookie) {
-            setCookieValues.push(fallbackSetCookie);
-          }
-          if (setCookieValues.length > 0) {
-            resHeaders["set-cookie"] = setCookieValues;
-          }
-          const responsePayload = {
-            type: "http_response",
-            id: request.id,
-            status: res.status,
-            headers: resHeaders,
-            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 === "ws_open") {
-        const request = payload;
-        const targetUrl = `ws://localhost:${input.port}${request.path.startsWith("/") ? request.path : `/${request.path}`}`;
-        const protocolsHeader = request.headers["sec-websocket-protocol"] ?? request.headers["Sec-WebSocket-Protocol"];
-        const protocols = protocolsHeader ? protocolsHeader.split(",").map((value) => value.trim()).filter(Boolean) : void 0;
-        const localWs = new WebSocket(targetUrl, protocols);
-        wsConnections.set(request.id, localWs);
-        localWs.onopen = () => {
-          ws.send(JSON.stringify({ type: "ws_ready", id: request.id }));
-          const queued = wsQueues.get(request.id);
-          if (queued) {
-            for (const message of queued) {
-              ws.send(JSON.stringify(message));
-            }
-            wsQueues.delete(request.id);
-          }
-        };
-        localWs.onmessage = (event2) => {
-          const data = typeof event2.data === "string" ? Buffer.from(event2.data) : Buffer.from(event2.data);
-          const response = {
-            type: "ws_message",
-            id: request.id,
-            dataBase64: data.toString("base64"),
-            isBinary: typeof event2.data !== "string"
-          };
-          ws.send(JSON.stringify(response));
-        };
-        localWs.onclose = (event2) => {
-          wsConnections.delete(request.id);
-          const response = {
-            type: "ws_close",
-            id: request.id,
-            code: event2.code,
-            reason: event2.reason
-          };
-          ws.send(JSON.stringify(response));
-        };
-        localWs.onerror = () => {
-          wsConnections.delete(request.id);
-          const response = {
-            type: "ws_close",
-            id: request.id,
-            code: 1011,
-            reason: "local_ws_error"
-          };
-          ws.send(JSON.stringify(response));
-        };
-      }
-      if (payload.type === "ws_message") {
-        const message = payload;
-        const localWs = wsConnections.get(message.id);
-        const data = Buffer.from(message.dataBase64, "base64");
-        if (!localWs || localWs.readyState !== WebSocket.OPEN) {
-          const queued = wsQueues.get(message.id) ?? [];
-          queued.push(message);
-          wsQueues.set(message.id, queued);
-          return;
-        }
-        if (message.isBinary) {
-          localWs.send(data);
-        } else {
-          localWs.send(data.toString());
-        }
-      }
-      if (payload.type === "ws_close") {
-        const message = payload;
-        const localWs = wsConnections.get(message.id);
-        if (!localWs) {
-          const queued = wsQueues.get(message.id) ?? [];
-          queued.push(message);
-          wsQueues.set(message.id, queued);
-          return;
-        }
-        localWs.close(message.code ?? 1e3, message.reason ?? "");
-        wsConnections.delete(message.id);
-      }
-      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";
-
-// src/local-browser/host.ts
-import { chromium } from "playwright";
-var HEARTBEAT_INTERVAL_MS = 3e4;
-var RECONNECT_DELAY_MS = 1e3;
-var MAX_RECONNECT_DELAY_MS = 3e4;
-var MAX_RECONNECT_ATTEMPTS = 10;
-var LocalBrowserHost = class {
-  options;
-  ws = null;
-  browser = null;
-  context = null;
-  page = null;
-  pendingDialogs = [];
-  heartbeatTimer = null;
-  reconnectAttempts = 0;
-  isShuttingDown = false;
-  lastSnapshotYaml = "";
-  constructor(options) {
-    this.options = options;
-  }
-  log(level, message, data) {
-    if (this.options.onLog) {
-      this.options.onLog(level, message, data);
-    } else {
-      const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-      fn(`[LocalBrowserHost] ${message}`, data ?? "");
-    }
-  }
-  // =========================================================================
-  // Lifecycle
-  // =========================================================================
-  async start() {
-    this.log("info", "Starting local browser host", {
-      browserMode: this.options.browserMode,
-      sessionId: this.options.sessionId
-    });
-    await this.connectWebSocket();
-    await this.launchBrowser();
-    this.sendSessionEvent("browser_ready");
-  }
-  async stop() {
-    this.isShuttingDown = true;
-    this.log("info", "Stopping local browser host");
-    this.stopHeartbeat();
-    if (this.ws) {
-      try {
-        this.ws.close(1e3, "Shutdown");
-      } catch {
-      }
-      this.ws = null;
-    }
-    if (this.context) {
-      try {
-        await this.context.close();
-      } catch {
-      }
-      this.context = null;
-    }
-    if (this.browser) {
-      try {
-        await this.browser.close();
-      } catch {
-      }
-      this.browser = null;
-    }
-    this.page = null;
-    this.log("info", "Local browser host stopped");
-  }
-  // =========================================================================
-  // WebSocket Connection
-  // =========================================================================
-  async connectWebSocket() {
-    return new Promise((resolve, reject) => {
-      const wsUrl = `${this.options.apiUrl.replace("http", "ws")}/local-browser/sessions/${this.options.sessionId}/connect?token=${this.options.wsToken}`;
-      this.log("info", "Connecting to cloud API", { url: wsUrl.replace(/token=.*/, "token=***") });
-      const ws = new WebSocket(wsUrl);
-      ws.onopen = () => {
-        this.log("info", "Connected to cloud API");
-        this.ws = ws;
-        this.reconnectAttempts = 0;
-        this.startHeartbeat();
-        resolve();
-      };
-      ws.onmessage = (event) => {
-        this.handleMessage(event.data);
-      };
-      ws.onerror = (event) => {
-        this.log("error", "WebSocket error", event);
-      };
-      ws.onclose = () => {
-        this.log("info", "WebSocket closed");
-        this.stopHeartbeat();
-        this.ws = null;
-        if (!this.isShuttingDown) {
-          this.scheduleReconnect();
-        }
-      };
-      setTimeout(() => {
-        if (!this.ws) {
-          reject(new Error("WebSocket connection timeout"));
-        }
-      }, 3e4);
-    });
-  }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      this.log("error", "Max reconnection attempts reached, giving up");
-      this.stop();
-      return;
-    }
-    const delay = Math.min(
-      RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts),
-      MAX_RECONNECT_DELAY_MS
-    );
-    this.reconnectAttempts++;
-    this.log("info", `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    setTimeout(async () => {
-      try {
-        await this.connectWebSocket();
-        this.sendSessionEvent("connected");
-        if (this.page) {
-          this.sendSessionEvent("browser_ready");
-        }
-      } catch (error) {
-        this.log("error", "Reconnection failed", error);
-        this.scheduleReconnect();
-      }
-    }, delay);
-  }
-  // =========================================================================
-  // Heartbeat
-  // =========================================================================
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        const ping = {
-          type: "heartbeat",
-          id: crypto.randomUUID(),
-          timestamp: Date.now(),
-          direction: "pong"
-        };
-        this.ws.send(JSON.stringify(ping));
-      }
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  // =========================================================================
-  // Browser Management
-  // =========================================================================
-  async launchBrowser() {
-    const { browserMode, cdpUrl, headless = true, storageStatePath } = this.options;
-    if (browserMode === "cdp" && cdpUrl) {
-      this.log("info", "Connecting to existing Chrome via CDP", { cdpUrl });
-      this.browser = await chromium.connectOverCDP(cdpUrl);
-      const contexts = this.browser.contexts();
-      this.context = contexts[0] ?? await this.browser.newContext();
-      const pages = this.context.pages();
-      this.page = pages[0] ?? await this.context.newPage();
-    } else {
-      this.log("info", "Launching new Playwright browser", { headless });
-      this.browser = await chromium.launch({
-        headless,
-        args: ["--no-sandbox"]
-      });
-      const contextOptions = {
-        viewport: { width: 1920, height: 1080 }
-      };
-      if (storageStatePath) {
-        try {
-          await Bun.file(storageStatePath).exists();
-          contextOptions.storageState = storageStatePath;
-          this.log("info", "Loading storage state", { storageStatePath });
-        } catch {
-          this.log("debug", "Storage state file not found, starting fresh");
-        }
-      }
-      this.context = await this.browser.newContext(contextOptions);
-      this.page = await this.context.newPage();
-    }
-    this.page.on("dialog", (dialog) => {
-      this.pendingDialogs.push(dialog);
-    });
-    this.log("info", "Browser ready");
-  }
-  // =========================================================================
-  // Message Handling
-  // =========================================================================
-  handleMessage(data) {
-    try {
-      const message = JSON.parse(data);
-      if (message.type === "heartbeat" && message.direction === "ping") {
-        const pong = {
-          type: "heartbeat",
-          id: crypto.randomUUID(),
-          timestamp: Date.now(),
-          direction: "pong"
-        };
-        this.ws?.send(JSON.stringify(pong));
-        return;
-      }
-      if (message.type === "command") {
-        this.handleCommand(message);
-        return;
-      }
-      this.log("debug", "Received unknown message type", message);
-    } catch (error) {
-      this.log("error", "Failed to parse message", { error, data });
-    }
-  }
-  async handleCommand(command) {
-    const startTime = Date.now();
-    this.log("debug", `Executing command: ${command.method}`, { id: command.id });
-    try {
-      const result = await this.executeMethod(command.method, command.args);
-      const response = {
-        type: "response",
-        id: crypto.randomUUID(),
-        timestamp: Date.now(),
-        requestId: command.id,
-        success: true,
-        result
-      };
-      this.ws?.send(JSON.stringify(response));
-      this.log("debug", `Command completed: ${command.method}`, {
-        id: command.id,
-        durationMs: Date.now() - startTime
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const response = {
-        type: "response",
-        id: crypto.randomUUID(),
-        timestamp: Date.now(),
-        requestId: command.id,
-        success: false,
-        error: errorMessage,
-        stack: error instanceof Error ? error.stack : void 0
-      };
-      this.ws?.send(JSON.stringify(response));
-      this.log("error", `Command failed: ${command.method}`, {
-        id: command.id,
-        error: errorMessage
-      });
-    }
-  }
-  sendSessionEvent(event, error) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-    const message = {
-      type: "session",
-      id: crypto.randomUUID(),
-      timestamp: Date.now(),
-      event,
-      browserMode: this.options.browserMode,
-      error
-    };
-    this.ws.send(JSON.stringify(message));
-  }
-  // =========================================================================
-  // Method Execution
-  // =========================================================================
-  async executeMethod(method, args) {
-    switch (method) {
-      // Lifecycle
-      case "connect":
-        return this.connect(args[0]);
-      case "disconnect":
-        return this.disconnect();
-      // Navigation
-      case "navigate":
-        return this.navigate(args[0], args[1]);
-      case "navigateBack":
-        return this.navigateBack(args[0]);
-      // Page Inspection
-      case "snapshot":
-        return this.snapshot(args[0]);
-      case "takeScreenshot":
-        return this.takeScreenshot(args[0]);
-      case "evaluate":
-        return this.evaluate(args[0], args[1]);
-      case "runCode":
-        return this.runCode(args[0], args[1]);
-      case "consoleMessages":
-        return this.consoleMessages(args[0]);
-      case "networkRequests":
-        return this.networkRequests(args[0]);
-      // Interaction
-      case "click":
-        return this.click(args[0], args[1], args[2]);
-      case "clickAtCoordinates":
-        return this.clickAtCoordinates(
-          args[0],
-          args[1],
-          args[2],
-          args[3]
-        );
-      case "moveToCoordinates":
-        return this.moveToCoordinates(
-          args[0],
-          args[1],
-          args[2],
-          args[3]
-        );
-      case "dragCoordinates":
-        return this.dragCoordinates(
-          args[0],
-          args[1],
-          args[2],
-          args[3],
-          args[4],
-          args[5]
-        );
-      case "hover":
-        return this.hover(args[0], args[1], args[2]);
-      case "drag":
-        return this.drag(
-          args[0],
-          args[1],
-          args[2],
-          args[3],
-          args[4]
-        );
-      case "type":
-        return this.type(
-          args[0],
-          args[1],
-          args[2],
-          args[3],
-          args[4]
-        );
-      case "pressKey":
-        return this.pressKey(args[0], args[1]);
-      case "fillForm":
-        return this.fillForm(args[0], args[1]);
-      case "selectOption":
-        return this.selectOption(
-          args[0],
-          args[1],
-          args[2],
-          args[3]
-        );
-      case "fileUpload":
-        return this.fileUpload(args[0], args[1]);
-      // Dialogs
-      case "handleDialog":
-        return this.handleDialog(args[0], args[1], args[2]);
-      // Waiting
-      case "waitFor":
-        return this.waitFor(args[0]);
-      // Browser Management
-      case "close":
-        return this.closePage(args[0]);
-      case "resize":
-        return this.resize(args[0], args[1], args[2]);
-      case "tabs":
-        return this.tabs(args[0], args[1], args[2]);
-      // Storage
-      case "getStorageState":
-        return this.getStorageState(args[0]);
-      case "getCurrentUrl":
-        return this.getCurrentUrl(args[0]);
-      case "getTitle":
-        return this.getTitle(args[0]);
-      case "getLinks":
-        return this.getLinks(args[0]);
-      case "getElementBoundingBox":
-        return this.getElementBoundingBox(args[0], args[1]);
-      // Tracing
-      case "startTracing":
-        return this.startTracing(args[0]);
-      case "stopTracing":
-        return this.stopTracing(args[0]);
-      // Video
-      case "isVideoRecordingEnabled":
-        return false;
-      // Video not supported in CLI host currently
-      case "saveVideo":
-        return null;
-      case "getVideoPath":
-        return null;
-      default:
-        throw new Error(`Unknown method: ${method}`);
-    }
-  }
-  // =========================================================================
-  // IBrowserClient Method Implementations
-  // =========================================================================
-  getPage() {
-    if (!this.page) throw new Error("No page available");
-    return this.page;
-  }
-  resolveRef(ref) {
-    return this.getPage().locator(`aria-ref=${ref}`);
-  }
-  async connect(_options) {
-    return;
-  }
-  async disconnect() {
-    await this.stop();
-  }
-  async navigate(url, _opts) {
-    const page = this.getPage();
-    await page.goto(url, { waitUntil: "domcontentloaded" });
-    await page.waitForLoadState("load", { timeout: 5e3 }).catch(() => {
-    });
-    return this.captureSnapshot();
-  }
-  async navigateBack(_opts) {
-    await this.getPage().goBack();
-    return this.captureSnapshot();
-  }
-  async snapshot(_opts) {
-    return this.captureSnapshot();
-  }
-  async captureSnapshot() {
-    const page = this.getPage();
-    this.lastSnapshotYaml = await page._snapshotForAI({ mode: "full" });
-    return this.lastSnapshotYaml;
-  }
-  async takeScreenshot(opts) {
-    const page = this.getPage();
-    const buffer = await page.screenshot({
-      type: opts?.type ?? "jpeg",
-      fullPage: opts?.fullPage ?? false
-    });
-    const mime = opts?.type === "png" ? "image/png" : "image/jpeg";
-    return `data:${mime};base64,${buffer.toString("base64")}`;
-  }
-  async evaluate(fn, _opts) {
-    const page = this.getPage();
-    return page.evaluate(new Function(`return (${fn})()`));
-  }
-  async runCode(code, _opts) {
-    const page = this.getPage();
-    const fn = new Function("page", `return (async () => { ${code} })()`);
-    return fn(page);
-  }
-  async consoleMessages(_opts) {
-    return "Console message capture not implemented in CLI host";
-  }
-  async networkRequests(_opts) {
-    return "Network request capture not implemented in CLI host";
-  }
-  async click(ref, _elementDesc, opts) {
-    const locator = this.resolveRef(ref);
-    await locator.scrollIntoViewIfNeeded({ timeout: 5e3 }).catch(() => {
-    });
-    const box = await locator.boundingBox();
-    if (box) {
-      const centerX = box.x + box.width / 2;
-      const centerY = box.y + box.height / 2;
-      const page = this.getPage();
-      if (opts?.modifiers?.length) {
-        for (const mod of opts.modifiers) {
-          await page.keyboard.down(mod);
-        }
-      }
-      if (opts?.doubleClick) {
-        await page.mouse.dblclick(centerX, centerY);
-      } else {
-        await page.mouse.click(centerX, centerY);
-      }
-      if (opts?.modifiers?.length) {
-        for (const mod of opts.modifiers) {
-          await page.keyboard.up(mod);
-        }
-      }
-    } else {
-      if (opts?.doubleClick) {
-        await locator.dblclick({ timeout: opts?.timeoutMs ?? 3e4 });
-      } else {
-        await locator.click({ timeout: opts?.timeoutMs ?? 3e4 });
-      }
-    }
-  }
-  async clickAtCoordinates(x, y, _elementDesc, opts) {
-    const page = this.getPage();
-    if (opts?.doubleClick) {
-      await page.mouse.dblclick(x, y);
-    } else {
-      await page.mouse.click(x, y);
-    }
-  }
-  async moveToCoordinates(x, y, _elementDesc, _opts) {
-    await this.getPage().mouse.move(x, y);
-  }
-  async dragCoordinates(startX, startY, endX, endY, _elementDesc, _opts) {
-    const page = this.getPage();
-    await page.mouse.move(startX, startY);
-    await page.mouse.down();
-    await page.mouse.move(endX, endY);
-    await page.mouse.up();
-  }
-  async hover(ref, _elementDesc, opts) {
-    await this.resolveRef(ref).hover({ timeout: opts?.timeoutMs ?? 3e4 });
-  }
-  async drag(startRef, _startElement, endRef, _endElement, opts) {
-    const startLocator = this.resolveRef(startRef);
-    const endLocator = this.resolveRef(endRef);
-    await startLocator.dragTo(endLocator, { timeout: opts?.timeoutMs ?? 6e4 });
-  }
-  async type(ref, text, _elementDesc, submit, opts) {
-    const locator = this.resolveRef(ref);
-    await locator.clear();
-    await locator.pressSequentially(text, {
-      delay: opts?.delay ?? 0,
-      timeout: opts?.timeoutMs ?? 3e4
-    });
-    if (submit) {
-      await locator.press("Enter");
-    }
-  }
-  async pressKey(key, _opts) {
-    await this.getPage().keyboard.press(key);
-  }
-  async fillForm(fields, opts) {
-    for (const field of fields) {
-      const locator = this.resolveRef(field.ref);
-      const fieldType = field.type ?? "textbox";
-      switch (fieldType) {
-        case "checkbox": {
-          const isChecked = await locator.isChecked();
-          const shouldBeChecked = field.value === "true";
-          if (shouldBeChecked !== isChecked) {
-            await locator.click({ timeout: opts?.timeoutMs ?? 3e4 });
-          }
-          break;
-        }
-        case "radio":
-          await locator.check({ timeout: opts?.timeoutMs ?? 3e4 });
-          break;
-        case "combobox":
-          await locator.selectOption(field.value, { timeout: opts?.timeoutMs ?? 3e4 });
-          break;
-        default:
-          await locator.fill(field.value, { timeout: opts?.timeoutMs ?? 3e4 });
-      }
-    }
-  }
-  async selectOption(ref, value, _elementDesc, opts) {
-    await this.resolveRef(ref).selectOption(value, { timeout: opts?.timeoutMs ?? 3e4 });
-  }
-  async fileUpload(paths, opts) {
-    const fileChooser = await this.getPage().waitForEvent("filechooser", {
-      timeout: opts?.timeoutMs ?? 3e4
-    });
-    await fileChooser.setFiles(paths);
-  }
-  async handleDialog(action, promptText, _opts) {
-    const dialog = this.pendingDialogs.shift();
-    if (dialog) {
-      if (action === "accept") {
-        await dialog.accept(promptText);
-      } else {
-        await dialog.dismiss();
-      }
-    }
-  }
-  async waitFor(opts) {
-    const page = this.getPage();
-    const timeout = opts?.timeout ?? opts?.timeoutMs ?? 3e4;
-    if (opts?.timeSec) {
-      await page.waitForTimeout(opts.timeSec * 1e3);
-      return;
-    }
-    if (opts?.text) {
-      await page.getByText(opts.text).first().waitFor({ state: "visible", timeout });
-      return;
-    }
-    if (opts?.textGone) {
-      await page.getByText(opts.textGone).first().waitFor({ state: "hidden", timeout });
-      return;
-    }
-    if (opts?.selector) {
-      await page.locator(opts.selector).waitFor({
-        state: opts.state ?? "visible",
-        timeout
-      });
-    }
-  }
-  async closePage(_opts) {
-    await this.getPage().close();
-    this.page = null;
-  }
-  async resize(width, height, _opts) {
-    await this.getPage().setViewportSize({ width, height });
-  }
-  async tabs(action, index, _opts) {
-    if (!this.context) throw new Error("No context available");
-    const pages = this.context.pages();
-    switch (action) {
-      case "list":
-        return Promise.all(
-          pages.map(async (p, i) => ({
-            index: i,
-            url: p.url(),
-            title: await p.title().catch(() => "")
-          }))
-        );
-      case "new": {
-        const newPage = await this.context.newPage();
-        this.page = newPage;
-        newPage.on("dialog", (dialog) => this.pendingDialogs.push(dialog));
-        return { index: pages.length };
-      }
-      case "close":
-        if (index !== void 0 && pages[index]) {
-          await pages[index].close();
-        } else {
-          await this.page?.close();
-        }
-        this.page = this.context.pages()[0] ?? null;
-        break;
-      case "select":
-        if (index !== void 0 && pages[index]) {
-          this.page = pages[index];
-        }
-        break;
-    }
-    return null;
-  }
-  async getStorageState(_opts) {
-    if (!this.context) throw new Error("No context available");
-    return this.context.storageState();
-  }
-  async getCurrentUrl(_opts) {
-    return this.getPage().url();
-  }
-  async getTitle(_opts) {
-    return this.getPage().title();
-  }
-  async getLinks(_opts) {
-    const page = this.getPage();
-    return page.$$eval(
-      "a[href]",
-      (links) => links.map((a) => a.href).filter((h) => !!h && (h.startsWith("http://") || h.startsWith("https://")))
-    );
-  }
-  async getElementBoundingBox(ref, _opts) {
-    const locator = this.resolveRef(ref);
-    const box = await locator.boundingBox();
-    if (!box) return null;
-    return { x: box.x, y: box.y, width: box.width, height: box.height };
-  }
-  async startTracing(_opts) {
-    if (!this.context) throw new Error("No context available");
-    await this.context.tracing.start({ screenshots: true, snapshots: true });
-  }
-  async stopTracing(_opts) {
-    if (!this.context) throw new Error("No context available");
-    const tracePath = `/tmp/trace-${Date.now()}.zip`;
-    await this.context.tracing.stop({ path: tracePath });
-    return {
-      trace: tracePath,
-      network: "",
-      resources: "",
-      directory: null,
-      legend: `Trace saved to ${tracePath}`
-    };
-  }
-};
-
-// src/mcp.ts
-var browserSessions = /* @__PURE__ */ new Map();
-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"]
-        }
-      },
-      {
-        name: "local_browser_start",
-        description: "Start a local browser session that connects to the cloud agent. The cloud agent can then control this browser to test local applications. Returns sessionId for tracking.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            mode: {
-              type: "string",
-              enum: ["playwright", "cdp"],
-              description: "Browser mode: 'playwright' for fresh browser, 'cdp' to connect to existing Chrome"
-            },
-            cdpUrl: {
-              type: "string",
-              description: "CDP endpoint URL when mode is 'cdp' (e.g. http://localhost:9222)"
-            },
-            headless: {
-              type: "boolean",
-              description: "Run browser headless (default: true for playwright mode)"
-            },
-            storageStatePath: {
-              type: "string",
-              description: "Path to Playwright storage state JSON for pre-authenticated sessions"
-            },
-            instructions: {
-              type: "string",
-              description: "Instructions for the cloud agent on what to test"
-            }
-          }
-        }
-      },
-      {
-        name: "local_browser_status",
-        description: "Check the status of a local browser session.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sessionId: { type: "string" }
-          },
-          required: ["sessionId"]
-        }
-      },
-      {
-        name: "local_browser_stop",
-        description: "Stop a local browser session and close the browser.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sessionId: { type: "string" }
-          },
-          required: ["sessionId"]
-        }
-      },
-      {
-        name: "local_browser_list",
-        description: "List all active local browser sessions.",
-        inputSchema: {
-          type: "object",
-          properties: {}
-        }
-      },
-      {
-        name: "local_browser_run",
-        description: "Start a test run on an active local browser session. The cloud agent will control the local browser according to the instructions.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sessionId: {
-              type: "string",
-              description: "The session ID from local_browser_start"
-            },
-            instructions: {
-              type: "string",
-              description: "Instructions for the cloud agent on what to test"
-            },
-            startUrl: {
-              type: "string",
-              description: "Optional URL to navigate to before starting"
-            }
-          },
-          required: ["sessionId", "instructions"]
-        }
-      }
-    ]
-  }));
-  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: void 0,
-        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);
-    }
-    if (tool === "local_browser_start") {
-      const input = req.params.arguments;
-      const apiUrl = resolveApiUrl();
-      const mode = input.mode ?? "playwright";
-      const sessionResponse = await fetch(`${apiUrl}/local-browser/sessions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          browserMode: mode,
-          instructions: input.instructions ?? null
-        })
-      });
-      if (!sessionResponse.ok) {
-        const text = await sessionResponse.text();
-        return toolJson({ ok: false, error: `Failed to create session: ${text}` });
-      }
-      const session = await sessionResponse.json();
-      const host = new LocalBrowserHost({
-        apiUrl,
-        wsToken: session.wsToken,
-        sessionId: session.sessionId,
-        browserMode: mode,
-        cdpUrl: input.cdpUrl,
-        headless: input.headless ?? true,
-        storageStatePath: input.storageStatePath,
-        onLog: (level, message) => {
-          if (level === "error") {
-            console.error(`[LocalBrowser] ${message}`);
-          }
-        }
-      });
-      host.start().catch((err) => {
-        console.error("Failed to start local browser:", err);
-        browserSessions.delete(session.sessionId);
-      });
-      browserSessions.set(session.sessionId, {
-        sessionId: session.sessionId,
-        host,
-        startedAt: Date.now(),
-        mode
-      });
-      return toolJson({
-        ok: true,
-        sessionId: session.sessionId,
-        mode,
-        expiresAt: session.expiresAt,
-        note: "Browser session started. The cloud agent can now control this browser. Use local_browser_stop to end the session."
-      });
-    }
-    if (tool === "local_browser_status") {
-      const input = req.params.arguments;
-      const session = browserSessions.get(input.sessionId);
-      if (!session) {
-        return toolJson({ ok: false, error: "Session not found", sessionId: input.sessionId });
-      }
-      return toolJson({
-        ok: true,
-        sessionId: session.sessionId,
-        mode: session.mode,
-        startedAt: new Date(session.startedAt).toISOString(),
-        uptimeMs: Date.now() - session.startedAt
-      });
-    }
-    if (tool === "local_browser_stop") {
-      const input = req.params.arguments;
-      const session = browserSessions.get(input.sessionId);
-      if (!session) {
-        return toolJson({ ok: false, error: "Session not found", sessionId: input.sessionId });
-      }
-      await session.host.stop();
-      browserSessions.delete(input.sessionId);
-      return toolJson({
-        ok: true,
-        sessionId: input.sessionId,
-        note: "Browser session stopped and browser closed."
-      });
-    }
-    if (tool === "local_browser_list") {
-      const sessions = Array.from(browserSessions.values()).map((s) => ({
-        sessionId: s.sessionId,
-        mode: s.mode,
-        startedAt: new Date(s.startedAt).toISOString(),
-        uptimeMs: Date.now() - s.startedAt
-      }));
-      return toolJson({
-        ok: true,
-        count: sessions.length,
-        sessions
-      });
-    }
-    if (tool === "local_browser_run") {
-      const input = req.params.arguments;
-      const apiUrl = resolveApiUrl();
-      const session = browserSessions.get(input.sessionId);
-      if (!session) {
-        return toolJson({
-          ok: false,
-          error: "Session not found locally. Make sure you started it with local_browser_start.",
-          sessionId: input.sessionId
-        });
-      }
-      const response = await fetch(`${apiUrl}/local-browser/sessions/${input.sessionId}/run`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          instructions: input.instructions,
-          startUrl: input.startUrl ?? null
-        })
-      });
-      if (!response.ok) {
-        const text = await response.text();
-        return toolJson({ ok: false, error: `Failed to start run: ${text}` });
-      }
-      const result = await response.json();
-      return toolJson({
-        ok: true,
-        jobId: result.jobId,
-        sessionId: result.sessionId,
-        note: "Test run started. The cloud agent is now controlling your local browser. You can watch the browser to see the test in action."
-      });
-    }
-    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({
-    onEvent: (event) => {
-      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/remote-test.ts
-import process7 from "process";
-import { createParser as createParser2 } from "eventsource-parser";
-function getArgValue5(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));
-}
-async function runRemoteTest(argv) {
-  const apiUrl = getArgValue5(argv, "--api-url") ?? process7.env.CANARY_API_URL ?? "https://api.trycanary.ai";
-  const token = getArgValue5(argv, "--token") ?? process7.env.CANARY_API_TOKEN ?? await readStoredToken();
-  const tag = getArgValue5(argv, "--tag");
-  const namePattern = getArgValue5(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_...");
-    process7.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}`);
-    process7.exit(1);
-  }
-  if (!triggerRes.ok) {
-    const errorText = await triggerRes.text();
-    console.error(`Failed to start tests: ${triggerRes.status}`);
-    console.error(errorText);
-    process7.exit(1);
-  }
-  const triggerData = await triggerRes.json();
-  if (!triggerData.ok || !triggerData.suiteId) {
-    console.error(`Failed to start tests: ${triggerData.error ?? "Unknown error"}`);
-    process7.exit(1);
-  }
-  const { suiteId, jobId } = 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}`);
-    process7.exit(1);
-  }
-  if (!streamRes.ok || !streamRes.body) {
-    console.error(`Failed to connect to event stream: ${streamRes.status}`);
-    process7.exit(1);
-  }
-  let exitCode = 0;
-  let hasCompleted = false;
-  const workflowNames = /* @__PURE__ */ new Map();
-  let totalWorkflows = 0;
-  let completedWorkflows = 0;
-  let failedWorkflows = 0;
-  let successfulWorkflows = 0;
-  const parser = createParser2({
-    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)}`);
-              }
-              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.");
-    process7.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)`);
-  }
-  process7.exit(exitCode);
-}
-
-// src/local-browser/index.ts
-import process8 from "process";
-var DEFAULT_API_URL2 = "https://api.trycanary.ai";
-function parseArgs(args) {
-  const options = {
-    mode: "playwright",
-    headless: true,
-    apiUrl: process8.env.CANARY_API_URL ?? DEFAULT_API_URL2
-  };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const nextArg = args[i + 1];
-    switch (arg) {
-      case "--mode":
-        if (nextArg === "playwright" || nextArg === "cdp") {
-          options.mode = nextArg;
-          i++;
-        }
-        break;
-      case "--cdp-url":
-        options.cdpUrl = nextArg;
-        options.mode = "cdp";
-        i++;
-        break;
-      case "--headless":
-        options.headless = true;
-        break;
-      case "--no-headless":
-        options.headless = false;
-        break;
-      case "--storage-state":
-        options.storageStatePath = nextArg;
-        i++;
-        break;
-      case "--api-url":
-        options.apiUrl = nextArg;
-        i++;
-        break;
-      case "--instructions":
-        options.instructions = nextArg;
-        i++;
-        break;
-    }
-  }
-  return options;
-}
-async function resolveToken2() {
-  const token = process8.env.CANARY_API_TOKEN ?? await readStoredToken();
-  if (!token) {
-    throw new Error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
-  }
-  return token;
-}
-async function createSession(apiUrl, token, options) {
-  const response = await fetch(`${apiUrl}/local-browser/sessions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({
-      browserMode: options.mode,
-      instructions: options.instructions ?? null
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`Failed to create session: ${response.status} ${text}`);
-  }
-  return response.json();
-}
-async function runLocalBrowser(args) {
-  const options = parseArgs(args);
-  console.log("Starting local browser...");
-  console.log(`  Mode: ${options.mode}`);
-  if (options.cdpUrl) {
-    console.log(`  CDP URL: ${options.cdpUrl}`);
-  }
-  console.log(`  Headless: ${options.headless}`);
-  console.log(`  API URL: ${options.apiUrl}`);
-  console.log();
-  const token = await resolveToken2();
-  console.log("Creating session with cloud API...");
-  const session = await createSession(options.apiUrl, token, options);
-  if (!session.ok) {
-    throw new Error(`Failed to create session: ${session.error}`);
-  }
-  console.log(`Session created: ${session.sessionId}`);
-  console.log(`Expires at: ${session.expiresAt}`);
-  console.log();
-  const host = new LocalBrowserHost({
-    apiUrl: options.apiUrl,
-    wsToken: session.wsToken,
-    sessionId: session.sessionId,
-    browserMode: options.mode,
-    cdpUrl: options.cdpUrl,
-    headless: options.headless,
-    storageStatePath: options.storageStatePath,
-    onLog: (level, message, data) => {
-      const prefix = `[${level.toUpperCase()}]`;
-      if (data) {
-        console.log(prefix, message, data);
-      } else {
-        console.log(prefix, message);
-      }
-    }
-  });
-  const shutdown = async () => {
-    console.log("\nShutting down...");
-    await host.stop();
-    process8.exit(0);
-  };
-  process8.on("SIGINT", shutdown);
-  process8.on("SIGTERM", shutdown);
-  try {
-    await host.start();
-    console.log();
-    console.log("Local browser is ready and connected to cloud.");
-    console.log("Press Ctrl+C to stop.");
-    console.log();
-    await new Promise(() => {
-    });
-  } catch (error) {
-    console.error("Failed to start local browser:", error);
-    await host.stop();
-    process8.exit(1);
-  }
-}
-
-// src/index.ts
-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 = process9.env.NODE_OPTIONS && preloadFlag ? `${process9.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process9.env.NODE_OPTIONS;
-  const env = {
-    ...process9.env,
-    CANARY_ENABLED: process9.env.CANARY_ENABLED ?? "1",
-    CANARY_RUNNER: "canary",
-    ...nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}
-  };
-  const result = spawnSync2(runnerBin, [playwrightCli, "test", ...args], {
-    env,
-    stdio: "inherit",
-    cwd: process9.cwd()
-  });
-  if (result.error) {
-    console.error("canary failed to launch Playwright:", result.error);
-    process9.exit(1);
-  }
-  process9.exit(result.status ?? 1);
-}
-function printHelp() {
-  console.log(
-    [
-      "canary: 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 [--app-url https://app.trycanary.ai] [--no-open]",
-      "  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",
-      "",
-      "Flags:",
-      "  -h, --help  Show help"
-    ].join("\n")
-  );
-}
-async function main(argv) {
-  if (argv.includes("--help") || argv.includes("-h")) {
-    printHelp();
-    return;
-  }
-  const [command, ...rest] = argv;
-  if (!command || command === "help") {
-    printHelp();
-    return;
-  }
-  if (command === "test") {
-    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") {
-    await runMcp(rest);
-    return;
-  }
-  if (command === "tunnel") {
-    await runTunnel(rest);
-    return;
-  }
-  if (command === "login") {
-    await runLogin(rest);
-    return;
-  }
-  if (command === "browser") {
-    await runLocalBrowser(rest);
-    return;
-  }
-  console.log(`Unknown command "${command}".`);
-  printHelp();
-  process9.exit(1);
-}
-if (import.meta.url === pathToFileURL2(process9.argv[1]).href) {
-  void main(process9.argv.slice(2));
-}
+import {
+  main
+} from "./chunk-YA43CE6P.js";
+import "./chunk-Z6I3ZXZL.js";
+import "./chunk-UBYYNMML.js";
+import "./chunk-7OCVIDC7.js";
 
 // src/bin.ts
 void main(process.argv.slice(2));