@canaryai/cli 0.1.5 → 0.1.9

package/dist/index.js

@@ -1,1574 +1,25 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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;
-  }
-}
-var init_auth = __esm({
-  "src/auth.ts"() {
-    "use strict";
-  }
-});
-
-// src/local-run.ts
-import process2 from "process";
-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 };
-}
-var init_local_run = __esm({
-  "src/local-run.ts"() {
-    "use strict";
-    init_auth();
-  }
-});
-
-// 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;
-}
-var init_tunnel = __esm({
-  "src/tunnel.ts"() {
-    "use strict";
-    init_auth();
-  }
-});
-
-// src/local-browser/host.ts
-import { chromium } from "playwright";
-var HEARTBEAT_INTERVAL_MS, RECONNECT_DELAY_MS, MAX_RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, LocalBrowserHost;
-var init_host = __esm({
-  "src/local-browser/host.ts"() {
-    "use strict";
-    HEARTBEAT_INTERVAL_MS = 3e4;
-    RECONNECT_DELAY_MS = 1e3;
-    MAX_RECONNECT_DELAY_MS = 3e4;
-    MAX_RECONNECT_ATTEMPTS = 10;
-    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 mcp_exports = {};
-__export(mcp_exports, {
-  runMcp: () => runMcp
-});
-import process7 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 as createParser2 } from "eventsource-parser";
-function resolveApiUrl(input) {
-  return input ?? process7.env.CANARY_API_URL ?? DEFAULT_API_URL;
-}
-async function resolveToken() {
-  const token = process7.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 = createParser2({
-    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
-  };
-}
-var browserSessions, DEFAULT_API_URL;
-var init_mcp = __esm({
-  "src/mcp.ts"() {
-    "use strict";
-    init_auth();
-    init_local_run();
-    init_tunnel();
-    init_host();
-    browserSessions = /* @__PURE__ */ new Map();
-    DEFAULT_API_URL = "https://api.trycanary.ai";
-  }
-});
-
-// src/local-browser/index.ts
-var local_browser_exports = {};
-__export(local_browser_exports, {
-  runLocalBrowser: () => runLocalBrowser
-});
-import process8 from "process";
-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);
-  }
-}
-var DEFAULT_API_URL2;
-var init_local_browser = __esm({
-  "src/local-browser/index.ts"() {
-    "use strict";
-    init_auth();
-    init_host();
-    DEFAULT_API_URL2 = "https://api.trycanary.ai";
-  }
-});
+import {
+  connectTunnel,
+  createLocalRun,
+  createTunnel,
+  runLocalTest,
+  runTunnel
+} from "./chunk-NRMZHITS.js";
+import {
+  readStoredApiUrl,
+  readStoredAuth,
+  readStoredToken,
+  saveAuth
+} from "./chunk-SGNA6N2N.js";
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
 
 // src/index.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import process9 from "process";
-import path5 from "path";
+import { createRequire as createRequire2 } from "module";
+import process7 from "process";
+import path4 from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 
 // src/runner/common.ts
@@ -1876,18 +327,29 @@ function countHealed(eventLogPath) {
   }
 }
 
-// src/index.ts
-init_local_run();
-init_tunnel();
-
 // src/login.ts
-import fs4 from "fs/promises";
-import os4 from "os";
-import path4 from "path";
-import process4 from "process";
+import process2 from "process";
+import readline from "readline";
 import { spawn as spawn2 } from "child_process";
-var DEFAULT_APP_URL = "https://app.trycanary.ai";
-function getArgValue3(argv, key) {
+var ENV_URLS = {
+  prod: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  production: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  dev: {
+    api: "https://api.dev.trycanary.ai",
+    app: "https://app.dev.trycanary.ai"
+  },
+  local: {
+    api: "http://localhost:3000",
+    app: "http://localhost:5173"
+  }
+};
+function getArgValue(argv, key) {
   const index = argv.indexOf(key);
   if (index === -1) return void 0;
   return argv[index + 1];
@@ -1896,7 +358,7 @@ function shouldOpenBrowser(argv) {
   return !argv.includes("--no-open");
 }
 function openUrl(url) {
-  const platform = process4.platform;
+  const platform = process2.platform;
   if (platform === "darwin") {
     spawn2("open", [url], { stdio: "ignore" });
     return;
@@ -1907,16 +369,48 @@ function openUrl(url) {
   }
   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;
+function promptChoice(question) {
+  const rl = readline.createInterface({ input: process2.stdin, output: process2.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function fetchOrgs(apiUrl, token) {
+  try {
+    const res = await fetch(`${apiUrl}/cli-login/orgs`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function switchOrg(apiUrl, token, orgId) {
+  const res = await fetch(`${apiUrl}/cli-login/switch-org`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ orgId })
+  });
+  return await res.json();
 }
 async function runLogin(argv) {
-  const 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 env = getArgValue(argv, "--env");
+  const envUrls = env ? ENV_URLS[env] : void 0;
+  if (env && !envUrls) {
+    console.error(`Unknown environment: ${env}`);
+    console.error("Valid environments: prod, dev, local");
+    process2.exit(1);
+  }
+  const apiUrl = getArgValue(argv, "--api-url") ?? envUrls?.api ?? process2.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const appUrl = getArgValue(argv, "--app-url") ?? envUrls?.app ?? process2.env.CANARY_APP_URL ?? "https://app.trycanary.ai";
+  const orgFlag = getArgValue(argv, "--org");
   const startRes = await fetch(`${apiUrl}/cli-login/start`, {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -1925,7 +419,7 @@ async function runLogin(argv) {
   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);
+    process2.exit(1);
   }
   console.log("Login required.");
   console.log(`User code: ${startJson.userCode}`);
@@ -1941,10 +435,12 @@ async function runLogin(argv) {
   }
   const intervalMs = (startJson.intervalSeconds ?? 3) * 1e3;
   const expiresAt = startJson.expiresAt ? new Date(startJson.expiresAt).getTime() : null;
+  let token;
+  let initialOrgId;
   while (true) {
     if (expiresAt && Date.now() > expiresAt) {
       console.error("Login code expired.");
-      process4.exit(1);
+      process2.exit(1);
     }
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
     const pollRes = await fetch(`${apiUrl}/cli-login/poll`, {
@@ -1955,50 +451,137 @@ async function runLogin(argv) {
     const pollJson = await pollRes.json();
     if (!pollRes.ok || !pollJson.ok) {
       console.error("Login poll failed", pollJson.error ?? pollRes.statusText);
-      process4.exit(1);
+      process2.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;
+      token = pollJson.accessToken;
+      initialOrgId = pollJson.orgId;
+      break;
     }
     if (pollJson.status === "rejected") {
       console.error("Login rejected.");
-      process4.exit(1);
+      process2.exit(1);
     }
     if (pollJson.status === "expired") {
       console.error("Login expired.");
-      process4.exit(1);
+      process2.exit(1);
+    }
+  }
+  const orgsData = await fetchOrgs(apiUrl, token);
+  const orgs = orgsData?.organizations ?? [];
+  let finalToken = token;
+  let finalOrgId = initialOrgId;
+  let finalOrgName;
+  if (orgs.length <= 1) {
+    finalOrgName = orgs[0]?.name;
+  } else {
+    let selectedOrg;
+    if (orgFlag) {
+      selectedOrg = orgs.find(
+        (o) => o.name.toLowerCase() === orgFlag.toLowerCase() || o.id === orgFlag
+      );
+      if (!selectedOrg) {
+        console.error(`Organization "${orgFlag}" not found. Available orgs:`);
+        for (const o of orgs) {
+          console.error(`  - ${o.name} (${o.id})`);
+        }
+        process2.exit(1);
+      }
+    } else if (process2.stdin.isTTY) {
+      console.log("\nYou belong to multiple organizations. Select one:");
+      for (let i = 0; i < orgs.length; i++) {
+        const marker = orgs[i].id === initialOrgId ? " (current)" : "";
+        console.log(`  ${i + 1}. ${orgs[i].name}${marker}`);
+      }
+      const answer = await promptChoice(`
+Choice [1-${orgs.length}]: `);
+      const idx = parseInt(answer, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= orgs.length) {
+        console.error("Invalid selection.");
+        process2.exit(1);
+      }
+      selectedOrg = orgs[idx];
+    } else {
+      const defaultOrg = orgs.find((o) => o.id === initialOrgId);
+      console.log(
+        `Warning: Multiple organizations available but running non-interactively. Using "${defaultOrg?.name ?? initialOrgId}".`
+      );
+      console.log("Tip: Use --org <name> to select a specific organization.");
+      selectedOrg = defaultOrg;
     }
+    if (selectedOrg && selectedOrg.id !== initialOrgId) {
+      const switchRes = await switchOrg(apiUrl, token, selectedOrg.id);
+      if (!switchRes.ok || !switchRes.accessToken) {
+        console.error("Failed to switch organization:", switchRes.error ?? "Unknown error");
+        process2.exit(1);
+      }
+      finalToken = switchRes.accessToken;
+      finalOrgId = switchRes.orgId;
+      finalOrgName = switchRes.orgName;
+    } else if (selectedOrg) {
+      finalOrgName = selectedOrg.name;
+    }
+  }
+  const filePath = await saveAuth({ token: finalToken, apiUrl, orgId: finalOrgId, orgName: finalOrgName });
+  const displayName = finalOrgName ? ` to ${finalOrgName}` : "";
+  console.log(`Login successful${displayName}. Token saved to ${filePath}`);
+  console.log("Set CANARY_API_TOKEN to use the CLI without re-login.");
+}
+
+// src/orgs.ts
+import process3 from "process";
+async function runOrgs(argv) {
+  const token = process3.env.CANARY_API_TOKEN ?? await readStoredToken();
+  if (!token) {
+    console.error("Not logged in. Run: canary login");
+    process3.exit(1);
   }
+  const auth = await readStoredAuth();
+  const apiUrl = process3.env.CANARY_API_URL ?? auth?.apiUrl ?? "https://api.trycanary.ai";
+  const res = await fetch(`${apiUrl}/cli-login/orgs`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    console.error("Failed to fetch organizations. You may need to re-login: canary login");
+    process3.exit(1);
+  }
+  const data = await res.json();
+  if (!data.ok || !data.organizations) {
+    console.error("Failed to fetch organizations:", data.error ?? "Unknown error");
+    process3.exit(1);
+  }
+  const currentOrgId = auth?.orgId ?? data.currentOrgId;
+  console.log("Organizations:\n");
+  for (const org of data.organizations) {
+    const marker = org.id === currentOrgId ? " *" : "";
+    console.log(`  ${org.name} (${org.role})${marker}`);
+  }
+  console.log("\n* = current organization");
+  console.log("To switch: canary login --org <name>");
 }
 
 // src/run-local.ts
-init_auth();
-init_local_run();
-init_tunnel();
-import process5 from "process";
-function getArgValue4(argv, key) {
+import process4 from "process";
+function getArgValue2(argv, key) {
   const index = argv.indexOf(key);
   if (index === -1) return void 0;
   return argv[index + 1];
 }
 async function runLocalSession(argv) {
-  const apiUrl = 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();
+  const apiUrl = getArgValue2(argv, "--api-url") ?? process4.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue2(argv, "--token") ?? process4.env.CANARY_API_TOKEN ?? await readStoredToken();
   if (!token) {
     console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
-    process5.exit(1);
+    process4.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");
+  const portRaw = getArgValue2(argv, "--port") ?? process4.env.CANARY_LOCAL_PORT;
+  const tunnelUrl = getArgValue2(argv, "--tunnel-url");
+  const title = getArgValue2(argv, "--title");
+  const featureSpec = getArgValue2(argv, "--feature");
+  const startUrl = getArgValue2(argv, "--start-url");
   if (!tunnelUrl && !portRaw) {
     console.error("Missing --port or --tunnel-url");
-    process5.exit(1);
+    process4.exit(1);
   }
   let publicUrl = tunnelUrl;
   let ws = null;
@@ -2006,7 +589,7 @@ async function runLocalSession(argv) {
     const port = Number(portRaw);
     if (Number.isNaN(port) || port <= 0) {
       console.error("Invalid --port value");
-      process5.exit(1);
+      process4.exit(1);
     }
     const tunnel = await createTunnel({ apiUrl, token, port });
     publicUrl = tunnel.publicUrl;
@@ -2022,7 +605,7 @@ async function runLocalSession(argv) {
   }
   if (!publicUrl) {
     console.error("Failed to resolve tunnel URL");
-    process5.exit(1);
+    process4.exit(1);
   }
   const run2 = await createLocalRun({
     apiUrl,
@@ -2038,19 +621,18 @@ async function runLocalSession(argv) {
   }
   if (ws) {
     console.log("Tunnel active. Press Ctrl+C to stop.");
-    process5.on("SIGINT", () => {
+    process4.on("SIGINT", () => {
       ws?.close();
-      process5.exit(0);
+      process4.exit(0);
     });
     await new Promise(() => void 0);
   }
 }
 
 // src/remote-test.ts
-init_auth();
-import process6 from "process";
+import process5 from "process";
 import { createParser } from "eventsource-parser";
-function getArgValue5(argv, key) {
+function getArgValue3(argv, key) {
   const index = argv.indexOf(key);
   if (index === -1 || index >= argv.length - 1) return void 0;
   return argv[index + 1];
@@ -2058,11 +640,20 @@ function getArgValue5(argv, key) {
 function hasFlag(argv, ...flags) {
   return flags.some((flag) => argv.includes(flag));
 }
+function formatFailedTests(failedTests, appUrl) {
+  if (failedTests.length === 0 || !appUrl) return null;
+  const lines = ["", "Failed tests:"];
+  for (const t of failedTests) {
+    lines.push(`  \u2717 ${t.name}`);
+    lines.push(`    ${appUrl}/runs/tests/${t.testRunId}`);
+  }
+  return lines.join("\n");
+}
 async function runRemoteTest(argv) {
-  const apiUrl = getArgValue5(argv, "--api-url") ?? process6.env.CANARY_API_URL ?? "https://api.trycanary.ai";
-  const token = getArgValue5(argv, "--token") ?? process6.env.CANARY_API_TOKEN ?? await readStoredToken();
-  const tag = getArgValue5(argv, "--tag");
-  const namePattern = getArgValue5(argv, "--name-pattern");
+  const apiUrl = getArgValue3(argv, "--api-url") ?? process5.env.CANARY_API_URL ?? "https://api.trycanary.ai";
+  const token = getArgValue3(argv, "--token") ?? process5.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const tag = getArgValue3(argv, "--tag");
+  const namePattern = getArgValue3(argv, "--name-pattern");
   const verbose = hasFlag(argv, "--verbose", "-v");
   if (!token) {
     console.error("Error: No API token found.");
@@ -2072,7 +663,7 @@ async function runRemoteTest(argv) {
     console.error("");
     console.error("Or create an API key in Settings > API Keys and pass it:");
     console.error("  canary test --remote --token cnry_...");
-    process6.exit(1);
+    process5.exit(1);
   }
   console.log("Starting remote workflow tests...");
   if (tag) console.log(`  Filtering by tag: ${tag}`);
@@ -2093,20 +684,20 @@ async function runRemoteTest(argv) {
     });
   } catch (err) {
     console.error(`Failed to connect to API: ${err}`);
-    process6.exit(1);
+    process5.exit(1);
   }
   if (!triggerRes.ok) {
     const errorText = await triggerRes.text();
     console.error(`Failed to start tests: ${triggerRes.status}`);
     console.error(errorText);
-    process6.exit(1);
+    process5.exit(1);
   }
   const triggerData = await triggerRes.json();
   if (!triggerData.ok || !triggerData.suiteId) {
     console.error(`Failed to start tests: ${triggerData.error ?? "Unknown error"}`);
-    process6.exit(1);
+    process5.exit(1);
   }
-  const { suiteId, jobId } = triggerData;
+  const { suiteId, jobId, appUrl } = triggerData;
   if (verbose) {
     console.log(`Suite ID: ${suiteId}`);
     console.log(`Job ID: ${jobId}`);
@@ -2123,15 +714,16 @@ async function runRemoteTest(argv) {
     });
   } catch (err) {
     console.error(`Failed to connect to event stream: ${err}`);
-    process6.exit(1);
+    process5.exit(1);
   }
   if (!streamRes.ok || !streamRes.body) {
     console.error(`Failed to connect to event stream: ${streamRes.status}`);
-    process6.exit(1);
+    process5.exit(1);
   }
   let exitCode = 0;
   let hasCompleted = false;
   const workflowNames = /* @__PURE__ */ new Map();
+  const failedTests = [];
   let totalWorkflows = 0;
   let completedWorkflows = 0;
   let failedWorkflows = 0;
@@ -2160,6 +752,7 @@ async function runRemoteTest(argv) {
               if (errorMessage) {
                 console.log(`    Error: ${errorMessage.slice(0, 200)}`);
               }
+              failedTests.push({ name, testRunId: testEvent.testRunId });
               exitCode = 1;
             } else if (status === "running") {
             } else if (status === "waiting") {
@@ -2201,7 +794,7 @@ async function runRemoteTest(argv) {
   console.log("\u2500".repeat(50));
   if (totalWorkflows === 0) {
     console.log("No workflows found matching the filter criteria.");
-    process6.exit(0);
+    process5.exit(0);
   }
   const passRate = totalWorkflows > 0 ? Math.round(successfulWorkflows / totalWorkflows * 100) : 0;
   if (failedWorkflows > 0) {
@@ -2214,83 +807,336 @@ async function runRemoteTest(argv) {
   if (waitingWorkflows > 0) {
     console.log(`Note: ${waitingWorkflows} workflow(s) are still waiting (scheduled for later)`);
   }
-  process6.exit(exitCode);
+  const failedSection = formatFailedTests(failedTests, appUrl);
+  if (failedSection) {
+    console.log(failedSection);
+  }
+  process5.exit(exitCode);
+}
+
+// src/debug-session.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+import process6 from "process";
+var ENV_URLS2 = {
+  prod: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  production: {
+    api: "https://api.trycanary.ai",
+    app: "https://app.trycanary.ai"
+  },
+  dev: {
+    api: "https://api.dev.trycanary.ai",
+    app: "https://app.dev.trycanary.ai"
+  },
+  local: {
+    api: "http://localhost:3000",
+    app: "http://localhost:5173"
+  }
+};
+function getArgValue4(argv, key) {
+  const index = argv.indexOf(key);
+  if (index === -1 || index >= argv.length - 1) return void 0;
+  return argv[index + 1];
+}
+function hasFlag2(argv, ...flags) {
+  return flags.some((flag) => argv.includes(flag));
+}
+async function writeDebugSession(loginUrl, expiresAt, apiUrl) {
+  const dir = path3.join(os2.homedir(), ".config", "canary-cli");
+  const filePath = path3.join(dir, "debug-session.json");
+  await fs3.mkdir(dir, { recursive: true, mode: 448 });
+  await fs3.writeFile(
+    filePath,
+    JSON.stringify({ loginUrl, expiresAt, apiUrl, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    { encoding: "utf8", mode: 384 }
+  );
+  return filePath;
+}
+async function runDebugSession(argv) {
+  const env = getArgValue4(argv, "--env");
+  const envUrls = env ? ENV_URLS2[env] : void 0;
+  if (env && !envUrls) {
+    console.error(`Unknown environment: ${env}`);
+    console.error("Valid environments: prod, dev, local");
+    process6.exit(1);
+  }
+  const storedApiUrl = await readStoredApiUrl();
+  const apiUrl = getArgValue4(argv, "--api-url") ?? envUrls?.api ?? process6.env.CANARY_API_URL ?? storedApiUrl ?? "https://api.trycanary.ai";
+  const token = getArgValue4(argv, "--token") ?? process6.env.CANARY_API_TOKEN ?? await readStoredToken();
+  const jsonOutput = hasFlag2(argv, "--json");
+  if (!token) {
+    console.error("Error: No API token found.");
+    console.error("Run: canary login [--env <env>]");
+    process6.exit(1);
+  }
+  try {
+    const res = await fetch(`${apiUrl}/auth/debug-session/create`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      if (res.status === 401) {
+        console.error("Error: Unauthorized. Your session may have expired.");
+        console.error("Run: canary login");
+        process6.exit(1);
+      }
+      if (res.status === 403) {
+        console.error("Error: Forbidden. Debug session creation requires superadmin access.");
+        process6.exit(1);
+      }
+      if (res.status === 404) {
+        console.error(
+          "Error: Endpoint not found. The debug-session feature may not be deployed to this environment."
+        );
+        process6.exit(1);
+      }
+      try {
+        const errorJson = JSON.parse(text);
+        console.error(`Error: ${errorJson.message ?? errorJson.error ?? text}`);
+      } catch {
+        console.error(`Error (${res.status}): ${text || res.statusText}`);
+      }
+      process6.exit(1);
+    }
+    const json = await res.json();
+    if (!json.ok || !json.loginUrl) {
+      console.error(`Error: ${json.message ?? json.error ?? "Failed to create debug session"}`);
+      process6.exit(1);
+    }
+    const filePath = await writeDebugSession(json.loginUrl, json.expiresAt ?? "", apiUrl);
+    if (jsonOutput) {
+      console.log(
+        JSON.stringify(
+          {
+            loginUrl: json.loginUrl,
+            expiresAt: json.expiresAt,
+            sessionFile: filePath
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log("Debug session created successfully.");
+      console.log("");
+      console.log(`Login URL: ${json.loginUrl}`);
+      console.log(`Expires: ${json.expiresAt}`);
+      console.log(`Session saved to: ${filePath}`);
+      console.log("");
+      console.log("Use this URL with Playwright to authenticate as the debug agent.");
+      console.log("The token is single-use and expires in 5 minutes.");
+    }
+  } catch (err) {
+    console.error(`Failed to create debug session: ${err}`);
+    process6.exit(1);
+  }
+}
+
+// src/jwt.ts
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const json = Buffer.from(base64, "base64").toString("utf8");
+    const payload = JSON.parse(json);
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+      return null;
+    }
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function isSuperadminToken(token) {
+  if (!token) return false;
+  const payload = decodeJwtPayload(token);
+  return payload?.is_superadmin === true;
 }
 
 // src/index.ts
-var loadMcp = () => Promise.resolve().then(() => (init_mcp(), mcp_exports)).then((m) => m.runMcp);
-var loadLocalBrowser = () => Promise.resolve().then(() => (init_local_browser(), local_browser_exports)).then((m) => m.runLocalBrowser);
+var require2 = createRequire2(import.meta.url);
+var pkg = require2("../package.json");
+var loadMcp = () => import("./mcp-5N5Z343W.js").then((m) => m.runMcp);
+var loadLocalBrowser = () => import("./local-browser-REU2RIYX.js").then((m) => m.runLocalBrowser);
 var canary = { run };
-var baseDir = typeof __dirname !== "undefined" ? __dirname : path5.dirname(fileURLToPath2(import.meta.url));
-var preloadPath = path5.join(baseDir, "runner", "preload.js");
+var baseDir = typeof __dirname !== "undefined" ? __dirname : path4.dirname(fileURLToPath2(import.meta.url));
+var preloadPath = path4.join(baseDir, "runner", "preload.js");
 var requireFn = makeRequire();
 function runPlaywrightTests(args) {
   const playwrightCli = requireFn.resolve("@playwright/test/cli");
   const { runnerBin, preloadFlag } = resolveRunner(preloadPath);
-  const nodeOptions = process9.env.NODE_OPTIONS && preloadFlag ? `${process9.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process9.env.NODE_OPTIONS;
+  const nodeOptions = process7.env.NODE_OPTIONS && preloadFlag ? `${process7.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process7.env.NODE_OPTIONS;
   const env = {
-    ...process9.env,
-    CANARY_ENABLED: process9.env.CANARY_ENABLED ?? "1",
+    ...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: process9.cwd()
+    cwd: process7.cwd()
   });
   if (result.error) {
     console.error("canary failed to launch Playwright:", result.error);
-    process9.exit(1);
+    process7.exit(1);
   }
-  process9.exit(result.status ?? 1);
+  process7.exit(result.status ?? 1);
+}
+function printVersion() {
+  console.log(`canary v${pkg.version}`);
+}
+function printHelp({ isSuperadmin }) {
+  const lines = [
+    `canary v${pkg.version}: Local and remote testing CLI`,
+    "",
+    "Usage:",
+    "  canary test [playwright options]        Run local Playwright tests",
+    "  canary test --remote [options]          Run remote workflow tests",
+    "  canary local-run --tunnel-url <url> [options]",
+    "  canary tunnel --port <localPort> [options]",
+    "  canary run --port <localPort> [options]",
+    "  canary mcp",
+    "  canary browser [--mode playwright|cdp] [--cdp-url <url>] [--no-headless]",
+    "  canary login [--org <name>] [--app-url https://app.trycanary.ai] [--no-open]",
+    "  canary orgs                            List organizations"
+  ];
+  if (isSuperadmin) {
+    lines.push(
+      "  canary debug-session [--env dev|local] [--json]  Create browser debug session",
+      "  canary psql <query> [--json]            Execute read-only SQL",
+      "  canary redis <command> [--json]         Execute read-only Redis commands",
+      "  canary feature-flag <sub-command>       Manage feature flags"
+    );
+  }
+  lines.push(
+    "  canary version                          Show version",
+    "  canary help",
+    "",
+    "Remote test options:",
+    "  --token <key>         API key (or set CANARY_API_TOKEN)",
+    "  --api-url <url>       API URL (default: https://api.trycanary.ai)",
+    "  --tag <tag>           Filter workflows by tag",
+    "  --name-pattern <pat>  Filter workflows by name pattern",
+    "  --verbose, -v         Show all events",
+    "",
+    "Browser options:",
+    "  --mode <playwright|cdp>  Browser mode (default: playwright)",
+    "  --cdp-url <url>          CDP endpoint for existing Chrome",
+    "  --no-headless            Run browser with visible UI",
+    "  --storage-state <path>   Path to storage state JSON",
+    "  --instructions <text>    Instructions for the cloud agent",
+    "",
+    "Login options:",
+    "  --org <name>          Select organization by name or ID (for multi-org users)",
+    "",
+    "Login environments:",
+    "  Production:  canary login",
+    "  Dev:         canary login --app-url https://app.dev.trycanary.ai --api-url https://api.dev.trycanary.ai",
+    "  Local:       canary login --app-url http://localhost:5173 --api-url http://localhost:3000",
+    "",
+    "  Or set CANARY_API_URL env var for non-production environments:",
+    "    export CANARY_API_URL=http://localhost:3000"
+  );
+  if (isSuperadmin) {
+    lines.push(
+      "",
+      "PSQL options:",
+      "  --json                Output results as JSON",
+      "  --query <sql>         SQL query (alternative to positional)",
+      "",
+      "Redis options:",
+      "  --json                Output results as JSON",
+      "",
+      "Feature flag sub-commands:",
+      "  list                               List all flags",
+      "  create <name> [--description <text>]  Create a flag",
+      "  delete <name>                      Delete a flag and its gates",
+      "  enable <name> --org <orgId>        Enable for an org",
+      "  disable <name> --org <orgId>       Disable for an org"
+    );
+  }
+  lines.push(
+    "",
+    "Flags:",
+    "  -h, --help     Show help",
+    "  -V, --version  Show version"
+  );
+  console.log(lines.join("\n"));
 }
-function printHelp() {
+function printTestHelp() {
   console.log(
     [
-      "canary: Local and remote testing CLI",
+      `canary v${pkg.version}: Test command`,
       "",
       "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",
+      "Local Playwright options (passed through to Playwright):",
+      "  --grep <pattern>       Only run tests matching pattern",
+      "  --headed               Run in headed browser mode",
+      "  --workers <n>          Number of parallel workers",
+      "  --project <name>       Run specific project",
+      "  --reporter <reporter>  Use a specific reporter",
+      "  --retries <n>          Number of retries for failed tests",
+      "  --timeout <ms>         Test timeout in milliseconds",
       "",
-      "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",
+      "Remote test options:",
+      "  --remote               Run tests remotely (required)",
+      "  --token <key>          API key (or set CANARY_API_TOKEN)",
+      "  --api-url <url>        API URL (default: https://api.trycanary.ai)",
+      "  --tag <tag>            Filter workflows by tag",
+      "  --name-pattern <pat>   Filter workflows by name pattern",
+      "  --verbose, -v          Show all events",
       "",
-      "Flags:",
-      "  -h, --help  Show help"
+      "Examples:",
+      "  canary test                             Run all local tests",
+      '  canary test --grep "login"              Run tests matching "login"',
+      "  canary test --headed --workers 1        Debug with visible browser",
+      "  canary test --remote --tag smoke        Run remote smoke tests"
     ].join("\n")
   );
 }
+var COMMANDS_WITH_HELP = /* @__PURE__ */ new Set(["test"]);
+async function resolveToken() {
+  return process7.env.CANARY_API_TOKEN ?? await readStoredToken();
+}
 async function main(argv) {
-  if (argv.includes("--help") || argv.includes("-h")) {
-    printHelp();
+  if (argv.includes("--version") || argv.includes("-V")) {
+    printVersion();
     return;
   }
   const [command, ...rest] = argv;
+  const hasHelpFlag = argv.includes("--help") || argv.includes("-h");
+  if (hasHelpFlag && (!command || !COMMANDS_WITH_HELP.has(command))) {
+    const token2 = await resolveToken();
+    printHelp({ isSuperadmin: isSuperadminToken(token2) });
+    return;
+  }
   if (!command || command === "help") {
-    printHelp();
+    const token2 = await resolveToken();
+    printHelp({ isSuperadmin: isSuperadminToken(token2) });
+    return;
+  }
+  if (command === "version") {
+    printVersion();
     return;
   }
   if (command === "test") {
+    if (rest.includes("--help") || rest.includes("-h")) {
+      printTestHelp();
+      return;
+    }
     if (rest.includes("--remote")) {
       const remoteArgs = rest.filter((arg) => arg !== "--remote");
       await runRemoteTest(remoteArgs);
@@ -2308,8 +1154,8 @@ async function main(argv) {
     return;
   }
   if (command === "mcp") {
-    const runMcp2 = await loadMcp();
-    await runMcp2(rest);
+    const runMcp = await loadMcp();
+    await runMcp(rest);
     return;
   }
   if (command === "tunnel") {
@@ -2320,17 +1166,41 @@ async function main(argv) {
     await runLogin(rest);
     return;
   }
+  if (command === "orgs") {
+    await runOrgs(rest);
+    return;
+  }
   if (command === "browser") {
-    const runLocalBrowser2 = await loadLocalBrowser();
-    await runLocalBrowser2(rest);
+    const runLocalBrowser = await loadLocalBrowser();
+    await runLocalBrowser(rest);
+    return;
+  }
+  if (command === "debug-session") {
+    await runDebugSession(rest);
+    return;
+  }
+  if (command === "psql") {
+    const { runPsql } = await import("./psql-7AEFGJWI.js");
+    await runPsql(rest);
+    return;
+  }
+  if (command === "redis") {
+    const { runRedis } = await import("./redis-BXYEPX4T.js");
+    await runRedis(rest);
+    return;
+  }
+  if (command === "feature-flag") {
+    const { runFeatureFlag } = await import("./feature-flag-43WAHIUZ.js");
+    await runFeatureFlag(rest);
     return;
   }
   console.log(`Unknown command "${command}".`);
-  printHelp();
-  process9.exit(1);
+  const token = await resolveToken();
+  printHelp({ isSuperadmin: isSuperadminToken(token) });
+  process7.exit(1);
 }
-if (import.meta.url === pathToFileURL2(process9.argv[1]).href) {
-  void main(process9.argv.slice(2));
+if (import.meta.url === pathToFileURL2(process7.argv[1]).href) {
+  void main(process7.argv.slice(2));
 }
 export {
   canary,