@canaryai/cli 0.1.1-alpha.2 → 0.1.4

package/dist/index.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/index.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import process7 from "process";
+import process9 from "process";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 
@@ -426,24 +426,67 @@ async function runTunnel(argv) {
     console.error("Missing token. Run `canary login` first or set CANARY_API_TOKEN.");
     process3.exit(1);
   }
-  const data = await createTunnel({
-    apiUrl,
-    token,
-    port
-  });
-  const ws = connectTunnel({
-    apiUrl,
-    tunnelId: data.tunnelId,
-    token: data.token,
-    port
-  });
-  ws.onopen = () => {
-    console.log(`Tunnel connected: ${data.publicUrl ?? data.tunnelId}`);
-    if (data.publicUrl) {
-      console.log(`Public URL: ${data.publicUrl}`);
+  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 new Promise(() => void 0);
+  await connect();
 }
 async function createTunnel(input) {
   const response = await fetch(`${input.apiUrl}/local-tests/tunnels`, {
@@ -468,6 +511,8 @@ function connectTunnel(input) {
     `${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?.();
   };
@@ -495,11 +540,22 @@ function connectTunnel(input) {
             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: Object.fromEntries(res.headers.entries()),
+            headers: resHeaders,
             bodyBase64: resBody.byteLength ? Buffer.from(resBody).toString("base64") : null
           };
           ws.send(JSON.stringify(responsePayload));
@@ -514,6 +570,82 @@ function connectTunnel(input) {
           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" }));
       }
@@ -693,6 +825,676 @@ 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;
@@ -740,6 +1542,88 @@ async function runMcp(argv) {
           },
           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"]
+        }
       }
     ]
   }));
@@ -762,7 +1646,7 @@ async function runMcp(argv) {
         token,
         title: input.title ?? "Local MCP run",
         featureSpec: input.instructions,
-        startUrl: null,
+        startUrl: void 0,
         tunnelUrl
       });
       return toolJson({
@@ -778,6 +1662,133 @@ async function runMcp(argv) {
       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();
@@ -802,19 +1813,20 @@ async function streamUntilComplete(input) {
   if (!response.body) return;
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
-  const parser = createParser((event) => {
-    if (event.type !== "event") return;
-    if (event.event === "status") {
-      try {
-        const payload = JSON.parse(event.data);
-        if (payload?.status === "completed" || payload?.status === "failed") {
-          reader.cancel().catch(() => void 0);
+  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 {
         }
-      } catch {
       }
-    }
-    if (event.event === "complete" || event.event === "error") {
-      reader.cancel().catch(() => void 0);
+      if (event.event === "complete" || event.event === "error") {
+        reader.cancel().catch(() => void 0);
+      }
     }
   });
   while (true) {
@@ -844,6 +1856,305 @@ function formatReport(input) {
   };
 }
 
+// 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 canary = { run };
 var baseDir = typeof __dirname !== "undefined" ? __dirname : path5.dirname(fileURLToPath2(import.meta.url));
@@ -852,38 +2163,54 @@ var requireFn = makeRequire();
 function runPlaywrightTests(args) {
   const playwrightCli = requireFn.resolve("@playwright/test/cli");
   const { runnerBin, preloadFlag } = resolveRunner(preloadPath);
-  const nodeOptions = process7.env.NODE_OPTIONS && preloadFlag ? `${process7.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process7.env.NODE_OPTIONS;
+  const nodeOptions = process9.env.NODE_OPTIONS && preloadFlag ? `${process9.env.NODE_OPTIONS} ${preloadFlag}` : preloadFlag ?? process9.env.NODE_OPTIONS;
   const env = {
-    ...process7.env,
-    CANARY_ENABLED: process7.env.CANARY_ENABLED ?? "1",
+    ...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: process7.cwd()
+    cwd: process9.cwd()
   });
   if (result.error) {
     console.error("canary failed to launch Playwright:", result.error);
-    process7.exit(1);
+    process9.exit(1);
   }
-  process7.exit(result.status ?? 1);
+  process9.exit(result.status ?? 1);
 }
 function printHelp() {
   console.log(
     [
-      "canary: Local testing CLI",
+      "canary: Local and remote testing CLI",
       "",
       "Usage:",
-      "  canary test [playwright options]",
+      "  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")
@@ -900,6 +2227,11 @@ async function main(argv) {
     return;
   }
   if (command === "test") {
+    if (rest.includes("--remote")) {
+      const remoteArgs = rest.filter((arg) => arg !== "--remote");
+      await runRemoteTest(remoteArgs);
+      return;
+    }
     runPlaywrightTests(rest);
     return;
   }
@@ -923,12 +2255,16 @@ async function main(argv) {
     await runLogin(rest);
     return;
   }
+  if (command === "browser") {
+    await runLocalBrowser(rest);
+    return;
+  }
   console.log(`Unknown command "${command}".`);
   printHelp();
-  process7.exit(1);
+  process9.exit(1);
 }
-if (import.meta.url === pathToFileURL2(process7.argv[1]).href) {
-  void main(process7.argv.slice(2));
+if (import.meta.url === pathToFileURL2(process9.argv[1]).href) {
+  void main(process9.argv.slice(2));
 }
 export {
   canary,