@canaryai/cli 0.1.11 → 0.1.13

package/dist/{chunk-G2X3H7AM.js → chunk-L26U3BST.js}

@@ -4,13 +4,12 @@ var HEARTBEAT_INTERVAL_MS = 3e4;
 var RECONNECT_DELAY_MS = 1e3;
 var MAX_RECONNECT_DELAY_MS = 3e4;
 var MAX_RECONNECT_ATTEMPTS = 10;
-var LocalBrowserHost = class {
+var LocalBrowserHost = class _LocalBrowserHost {
   options;
   ws = null;
   browser = null;
-  context = null;
-  page = null;
-  pendingDialogs = [];
+  contexts = /* @__PURE__ */ new Map();
+  static DEFAULT_CONTEXT_ID = "__default__";
   heartbeatTimer = null;
   reconnectAttempts = 0;
   isShuttingDown = false;
@@ -49,13 +48,13 @@ var LocalBrowserHost = class {
       }
       this.ws = null;
     }
-    if (this.context) {
+    for (const [id, slot] of this.contexts) {
       try {
-        await this.context.close();
+        await slot.context.close();
       } catch {
       }
-      this.context = null;
     }
+    this.contexts.clear();
     if (this.browser) {
       try {
         await this.browser.close();
@@ -63,7 +62,6 @@ var LocalBrowserHost = class {
       }
       this.browser = null;
     }
-    this.page = null;
     this.log("info", "Local browser host stopped");
   }
   // =========================================================================
@@ -158,10 +156,13 @@ var LocalBrowserHost = class {
     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();
+      const existingContexts = this.browser.contexts();
+      const ctx = existingContexts[0] ?? await this.browser.newContext();
+      const pages = ctx.pages();
+      const pg = pages[0] ?? await ctx.newPage();
+      const slot = { context: ctx, page: pg, pendingDialogs: [] };
+      pg.on("dialog", (dialog) => slot.pendingDialogs.push(dialog));
+      this.contexts.set(_LocalBrowserHost.DEFAULT_CONTEXT_ID, slot);
     } else {
       this.log("info", "Launching new Playwright browser", { headless });
       this.browser = await chromium.launch({
@@ -180,12 +181,12 @@ var LocalBrowserHost = class {
           this.log("debug", "Storage state file not found, starting fresh");
         }
       }
-      this.context = await this.browser.newContext(contextOptions);
-      this.page = await this.context.newPage();
+      const ctx = await this.browser.newContext(contextOptions);
+      const pg = await ctx.newPage();
+      const slot = { context: ctx, page: pg, pendingDialogs: [] };
+      pg.on("dialog", (dialog) => slot.pendingDialogs.push(dialog));
+      this.contexts.set(_LocalBrowserHost.DEFAULT_CONTEXT_ID, slot);
     }
-    this.page.on("dialog", (dialog) => {
-      this.pendingDialogs.push(dialog);
-    });
     this.log("info", "Browser ready");
   }
   // =========================================================================
@@ -215,20 +216,23 @@ var LocalBrowserHost = class {
   }
   async handleCommand(command) {
     const startTime = Date.now();
-    this.log("debug", `Executing command: ${command.method}`, { id: command.id });
+    const contextId = command.contextId;
+    this.log("debug", `Executing command: ${command.method}`, { id: command.id, contextId });
     try {
-      const result = await this.executeMethod(command.method, command.args);
+      const result = await this.executeMethod(command.method, command.args, contextId);
       const response = {
         type: "response",
         id: crypto.randomUUID(),
         timestamp: Date.now(),
         requestId: command.id,
         success: true,
-        result
+        result,
+        contextId
       };
       this.ws?.send(JSON.stringify(response));
       this.log("debug", `Command completed: ${command.method}`, {
         id: command.id,
+        contextId,
         durationMs: Date.now() - startTime
       });
     } catch (error) {
@@ -240,11 +244,13 @@ var LocalBrowserHost = class {
         requestId: command.id,
         success: false,
         error: errorMessage,
-        stack: error instanceof Error ? error.stack : void 0
+        stack: error instanceof Error ? error.stack : void 0,
+        contextId
       };
       this.ws?.send(JSON.stringify(response));
       this.log("error", `Command failed: ${command.method}`, {
         id: command.id,
+        contextId,
         error: errorMessage
       });
     }
@@ -264,7 +270,51 @@ var LocalBrowserHost = class {
   // =========================================================================
   // Method Execution
   // =========================================================================
-  async executeMethod(method, args) {
+  getSlot(contextId) {
+    const id = contextId ?? _LocalBrowserHost.DEFAULT_CONTEXT_ID;
+    const slot = this.contexts.get(id);
+    if (!slot) throw new Error(`Context not found: ${id}`);
+    return slot;
+  }
+  async createContextSlot(contextId, options) {
+    if (!this.browser) throw new Error("No browser available");
+    if (this.contexts.has(contextId)) throw new Error(`Context already exists: ${contextId}`);
+    const contextOptions = {
+      viewport: { width: 1920, height: 1080 }
+    };
+    if (options?.storageState) {
+      const tmpPath = `/tmp/storage-state-${crypto.randomUUID()}.json`;
+      await Bun.write(tmpPath, JSON.stringify(options.storageState));
+      contextOptions.storageState = tmpPath;
+      this.log("info", "Loaded inline storage state for new context", { contextId });
+    }
+    const ctx = await this.browser.newContext(contextOptions);
+    const pg = await ctx.newPage();
+    const slot = { context: ctx, page: pg, pendingDialogs: [] };
+    pg.on("dialog", (dialog) => slot.pendingDialogs.push(dialog));
+    this.contexts.set(contextId, slot);
+    this.log("info", "Created new context slot", { contextId });
+  }
+  async destroyContextSlot(contextId) {
+    if (contextId === _LocalBrowserHost.DEFAULT_CONTEXT_ID) {
+      throw new Error("Cannot destroy the default context");
+    }
+    const slot = this.contexts.get(contextId);
+    if (!slot) throw new Error(`Context not found: ${contextId}`);
+    try {
+      await slot.context.close();
+    } catch {
+    }
+    this.contexts.delete(contextId);
+    this.log("info", "Destroyed context slot", { contextId });
+  }
+  async executeMethod(method, args, contextId) {
+    switch (method) {
+      case "createContext":
+        return this.createContextSlot(args[0], args[1]);
+      case "destroyContext":
+        return this.destroyContextSlot(args[0]);
+    }
     switch (method) {
       // Lifecycle
       case "connect":
@@ -273,38 +323,40 @@ var LocalBrowserHost = class {
         return this.disconnect();
       // Navigation
       case "navigate":
-        return this.navigate(args[0], args[1]);
+        return this.navigate(args[0], args[1], contextId);
       case "navigateBack":
-        return this.navigateBack(args[0]);
+        return this.navigateBack(args[0], contextId);
       // Page Inspection
       case "snapshot":
-        return this.snapshot(args[0]);
+        return this.snapshot(args[0], contextId);
       case "takeScreenshot":
-        return this.takeScreenshot(args[0]);
+        return this.takeScreenshot(args[0], contextId);
       case "evaluate":
-        return this.evaluate(args[0], args[1]);
+        return this.evaluate(args[0], args[1], contextId);
       case "runCode":
-        return this.runCode(args[0], args[1]);
+        return this.runCode(args[0], args[1], contextId);
       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]);
+        return this.click(args[0], args[1], args[2], contextId);
       case "clickAtCoordinates":
         return this.clickAtCoordinates(
           args[0],
           args[1],
           args[2],
-          args[3]
+          args[3],
+          contextId
         );
       case "moveToCoordinates":
         return this.moveToCoordinates(
           args[0],
           args[1],
           args[2],
-          args[3]
+          args[3],
+          contextId
         );
       case "dragCoordinates":
         return this.dragCoordinates(
@@ -313,17 +365,19 @@ var LocalBrowserHost = class {
           args[2],
           args[3],
           args[4],
-          args[5]
+          args[5],
+          contextId
         );
       case "hover":
-        return this.hover(args[0], args[1], args[2]);
+        return this.hover(args[0], args[1], args[2], contextId);
       case "drag":
         return this.drag(
           args[0],
           args[1],
           args[2],
           args[3],
-          args[4]
+          args[4],
+          contextId
         );
       case "type":
         return this.type(
@@ -331,50 +385,55 @@ var LocalBrowserHost = class {
           args[1],
           args[2],
           args[3],
-          args[4]
+          args[4],
+          contextId
         );
       case "pressKey":
-        return this.pressKey(args[0], args[1]);
+        return this.pressKey(args[0], args[1], contextId);
       case "fillForm":
-        return this.fillForm(args[0], args[1]);
+        return this.fillForm(args[0], args[1], contextId);
       case "selectOption":
         return this.selectOption(
           args[0],
           args[1],
           args[2],
-          args[3]
+          args[3],
+          contextId
         );
       case "fileUpload":
-        return this.fileUpload(args[0], args[1]);
+        return this.fileUpload(args[0], args[1], contextId);
       // Dialogs
       case "handleDialog":
-        return this.handleDialog(args[0], args[1], args[2]);
+        return this.handleDialog(args[0], args[1], args[2], contextId);
       // Waiting
       case "waitFor":
-        return this.waitFor(args[0]);
+        return this.waitFor(args[0], contextId);
       // Browser Management
       case "close":
-        return this.closePage(args[0]);
+        return this.closePage(args[0], contextId);
       case "resize":
-        return this.resize(args[0], args[1], args[2]);
+        return this.resize(args[0], args[1], args[2], contextId);
       case "tabs":
-        return this.tabs(args[0], args[1], args[2]);
+        return this.tabs(args[0], args[1], args[2], contextId);
+      // Context Management
+      case "swapContext":
+        return this.handleSwapContext(args[0], contextId);
       // Storage
       case "getStorageState":
-        return this.getStorageState(args[0]);
+        return this.getStorageState(args[0], contextId);
       case "getCurrentUrl":
-        return this.getCurrentUrl(args[0]);
+        return this.getCurrentUrl(args[0], contextId);
       case "getTitle":
-        return this.getTitle(args[0]);
+        return this.getTitle(args[0], contextId);
       case "getLinks":
-        return this.getLinks(args[0]);
+        return this.getLinks(args[0], contextId);
       case "getElementBoundingBox":
-        return this.getElementBoundingBox(args[0], args[1]);
+        return this.getElementBoundingBox(args[0], args[1], contextId);
       // Tracing
       case "startTracing":
-        return this.startTracing(args[0]);
+        return this.startTracing(args[0], contextId);
       case "stopTracing":
-        return this.stopTracing(args[0]);
+        return this.stopTracing(args[0], contextId);
       // Video
       case "isVideoRecordingEnabled":
         return false;
@@ -390,12 +449,47 @@ var LocalBrowserHost = class {
   // =========================================================================
   // IBrowserClient Method Implementations
   // =========================================================================
-  getPage() {
-    if (!this.page) throw new Error("No page available");
-    return this.page;
+  async handleSwapContext(options, contextId) {
+    if (!this.browser) throw new Error("No browser available");
+    const slotId = contextId ?? _LocalBrowserHost.DEFAULT_CONTEXT_ID;
+    const existing = this.contexts.get(slotId);
+    if (existing) {
+      await existing.context.close();
+      this.contexts.delete(slotId);
+    }
+    const contextOptions = {
+      viewport: { width: 1920, height: 1080 }
+    };
+    if (options.storageState) {
+      const tmpPath = `/tmp/storage-state-${crypto.randomUUID()}.json`;
+      await Bun.write(tmpPath, JSON.stringify(options.storageState));
+      contextOptions.storageState = tmpPath;
+      this.log("info", "Loaded inline storage state for context swap");
+    } else if (options.storageStatePath) {
+      try {
+        const exists = await Bun.file(options.storageStatePath).exists();
+        if (exists) {
+          contextOptions.storageState = options.storageStatePath;
+          this.log("info", "Loading storage state from file for context swap", {
+            storageStatePath: options.storageStatePath
+          });
+        }
+      } catch {
+        this.log("debug", "Storage state file not found, starting fresh context");
+      }
+    }
+    const ctx = await this.browser.newContext(contextOptions);
+    const pg = await ctx.newPage();
+    const slot = { context: ctx, page: pg, pendingDialogs: [] };
+    pg.on("dialog", (dialog) => slot.pendingDialogs.push(dialog));
+    this.contexts.set(slotId, slot);
+    this.log("info", "Browser context swapped successfully", { contextId: slotId });
   }
-  resolveRef(ref) {
-    return this.getPage().locator(`aria-ref=${ref}`);
+  getPage(contextId) {
+    return this.getSlot(contextId).page;
+  }
+  resolveRef(ref, contextId) {
+    return this.getPage(contextId).locator(`aria-ref=${ref}`);
   }
   async connect(_options) {
     return;
@@ -403,27 +497,27 @@ var LocalBrowserHost = class {
   async disconnect() {
     await this.stop();
   }
-  async navigate(url, _opts) {
-    const page = this.getPage();
+  async navigate(url, _opts, contextId) {
+    const page = this.getPage(contextId);
     await page.goto(url, { waitUntil: "domcontentloaded" });
     await page.waitForLoadState("load", { timeout: 5e3 }).catch(() => {
     });
-    return this.captureSnapshot();
+    return this.captureSnapshot(contextId);
   }
-  async navigateBack(_opts) {
-    await this.getPage().goBack();
-    return this.captureSnapshot();
+  async navigateBack(_opts, contextId) {
+    await this.getPage(contextId).goBack();
+    return this.captureSnapshot(contextId);
   }
-  async snapshot(_opts) {
-    return this.captureSnapshot();
+  async snapshot(_opts, contextId) {
+    return this.captureSnapshot(contextId);
   }
-  async captureSnapshot() {
-    const page = this.getPage();
+  async captureSnapshot(contextId) {
+    const page = this.getPage(contextId);
     this.lastSnapshotYaml = await page._snapshotForAI({ mode: "full" });
     return this.lastSnapshotYaml;
   }
-  async takeScreenshot(opts) {
-    const page = this.getPage();
+  async takeScreenshot(opts, contextId) {
+    const page = this.getPage(contextId);
     const buffer = await page.screenshot({
       type: opts?.type ?? "jpeg",
       fullPage: opts?.fullPage ?? false
@@ -431,12 +525,12 @@ var LocalBrowserHost = class {
     const mime = opts?.type === "png" ? "image/png" : "image/jpeg";
     return `data:${mime};base64,${buffer.toString("base64")}`;
   }
-  async evaluate(fn, _opts) {
-    const page = this.getPage();
+  async evaluate(fn, _opts, contextId) {
+    const page = this.getPage(contextId);
     return page.evaluate(new Function(`return (${fn})()`));
   }
-  async runCode(code, _opts) {
-    const page = this.getPage();
+  async runCode(code, _opts, contextId) {
+    const page = this.getPage(contextId);
     const fn = new Function("page", `return (async () => { ${code} })()`);
     return fn(page);
   }
@@ -446,15 +540,15 @@ var LocalBrowserHost = class {
   async networkRequests(_opts) {
     return "Network request capture not implemented in CLI host";
   }
-  async click(ref, _elementDesc, opts) {
-    const locator = this.resolveRef(ref);
+  async click(ref, _elementDesc, opts, contextId) {
+    const locator = this.resolveRef(ref, contextId);
     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();
+      const page = this.getPage(contextId);
       if (opts?.modifiers?.length) {
         for (const mod of opts.modifiers) {
           await page.keyboard.down(mod);
@@ -478,34 +572,34 @@ var LocalBrowserHost = class {
       }
     }
   }
-  async clickAtCoordinates(x, y, _elementDesc, opts) {
-    const page = this.getPage();
+  async clickAtCoordinates(x, y, _elementDesc, opts, contextId) {
+    const page = this.getPage(contextId);
     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 moveToCoordinates(x, y, _elementDesc, _opts, contextId) {
+    await this.getPage(contextId).mouse.move(x, y);
   }
-  async dragCoordinates(startX, startY, endX, endY, _elementDesc, _opts) {
-    const page = this.getPage();
+  async dragCoordinates(startX, startY, endX, endY, _elementDesc, _opts, contextId) {
+    const page = this.getPage(contextId);
     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 hover(ref, _elementDesc, opts, contextId) {
+    await this.resolveRef(ref, contextId).hover({ timeout: opts?.timeoutMs ?? 3e4 });
   }
-  async drag(startRef, _startElement, endRef, _endElement, opts) {
-    const startLocator = this.resolveRef(startRef);
-    const endLocator = this.resolveRef(endRef);
+  async drag(startRef, _startElement, endRef, _endElement, opts, contextId) {
+    const startLocator = this.resolveRef(startRef, contextId);
+    const endLocator = this.resolveRef(endRef, contextId);
     await startLocator.dragTo(endLocator, { timeout: opts?.timeoutMs ?? 6e4 });
   }
-  async type(ref, text, _elementDesc, submit, opts) {
-    const locator = this.resolveRef(ref);
+  async type(ref, text, _elementDesc, submit, opts, contextId) {
+    const locator = this.resolveRef(ref, contextId);
     await locator.clear();
     await locator.pressSequentially(text, {
       delay: opts?.delay ?? 0,
@@ -515,12 +609,12 @@ var LocalBrowserHost = class {
       await locator.press("Enter");
     }
   }
-  async pressKey(key, _opts) {
-    await this.getPage().keyboard.press(key);
+  async pressKey(key, _opts, contextId) {
+    await this.getPage(contextId).keyboard.press(key);
   }
-  async fillForm(fields, opts) {
+  async fillForm(fields, opts, contextId) {
     for (const field of fields) {
-      const locator = this.resolveRef(field.ref);
+      const locator = this.resolveRef(field.ref, contextId);
       const fieldType = field.type ?? "textbox";
       switch (fieldType) {
         case "checkbox": {
@@ -542,17 +636,18 @@ var LocalBrowserHost = class {
       }
     }
   }
-  async selectOption(ref, value, _elementDesc, opts) {
-    await this.resolveRef(ref).selectOption(value, { timeout: opts?.timeoutMs ?? 3e4 });
+  async selectOption(ref, value, _elementDesc, opts, contextId) {
+    await this.resolveRef(ref, contextId).selectOption(value, { timeout: opts?.timeoutMs ?? 3e4 });
   }
-  async fileUpload(paths, opts) {
-    const fileChooser = await this.getPage().waitForEvent("filechooser", {
+  async fileUpload(paths, opts, contextId) {
+    const fileChooser = await this.getPage(contextId).waitForEvent("filechooser", {
       timeout: opts?.timeoutMs ?? 3e4
     });
     await fileChooser.setFiles(paths);
   }
-  async handleDialog(action, promptText, _opts) {
-    const dialog = this.pendingDialogs.shift();
+  async handleDialog(action, promptText, _opts, contextId) {
+    const slot = this.getSlot(contextId);
+    const dialog = slot.pendingDialogs.shift();
     if (dialog) {
       if (action === "accept") {
         await dialog.accept(promptText);
@@ -561,8 +656,8 @@ var LocalBrowserHost = class {
       }
     }
   }
-  async waitFor(opts) {
-    const page = this.getPage();
+  async waitFor(opts, contextId) {
+    const page = this.getPage(contextId);
     const timeout = opts?.timeout ?? opts?.timeoutMs ?? 3e4;
     if (opts?.timeSec) {
       await page.waitForTimeout(opts.timeSec * 1e3);
@@ -583,16 +678,20 @@ var LocalBrowserHost = class {
       });
     }
   }
-  async closePage(_opts) {
-    await this.getPage().close();
-    this.page = null;
+  async closePage(_opts, contextId) {
+    const slot = this.getSlot(contextId);
+    await slot.page.close();
+    const remaining = slot.context.pages();
+    if (remaining.length > 0) {
+      slot.page = remaining[0];
+    }
   }
-  async resize(width, height, _opts) {
-    await this.getPage().setViewportSize({ width, height });
+  async resize(width, height, _opts, contextId) {
+    await this.getPage(contextId).setViewportSize({ width, height });
   }
-  async tabs(action, index, _opts) {
-    if (!this.context) throw new Error("No context available");
-    const pages = this.context.pages();
+  async tabs(action, index, _opts, contextId) {
+    const slot = this.getSlot(contextId);
+    const pages = slot.context.pages();
     switch (action) {
       case "list":
         return Promise.all(
@@ -603,58 +702,58 @@ var LocalBrowserHost = class {
           }))
         );
       case "new": {
-        const newPage = await this.context.newPage();
-        this.page = newPage;
-        newPage.on("dialog", (dialog) => this.pendingDialogs.push(dialog));
+        const newPage = await slot.context.newPage();
+        slot.page = newPage;
+        newPage.on("dialog", (dialog) => slot.pendingDialogs.push(dialog));
         return { index: pages.length };
       }
       case "close":
         if (index !== void 0 && pages[index]) {
           await pages[index].close();
         } else {
-          await this.page?.close();
+          await slot.page.close();
         }
-        this.page = this.context.pages()[0] ?? null;
+        slot.page = slot.context.pages()[0] ?? slot.page;
         break;
       case "select":
         if (index !== void 0 && pages[index]) {
-          this.page = pages[index];
+          slot.page = pages[index];
         }
         break;
     }
     return null;
   }
-  async getStorageState(_opts) {
-    if (!this.context) throw new Error("No context available");
-    return this.context.storageState();
+  async getStorageState(_opts, contextId) {
+    const slot = this.getSlot(contextId);
+    return slot.context.storageState();
   }
-  async getCurrentUrl(_opts) {
-    return this.getPage().url();
+  async getCurrentUrl(_opts, contextId) {
+    return this.getPage(contextId).url();
   }
-  async getTitle(_opts) {
-    return this.getPage().title();
+  async getTitle(_opts, contextId) {
+    return this.getPage(contextId).title();
   }
-  async getLinks(_opts) {
-    const page = this.getPage();
+  async getLinks(_opts, contextId) {
+    const page = this.getPage(contextId);
     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);
+  async getElementBoundingBox(ref, _opts, contextId) {
+    const locator = this.resolveRef(ref, contextId);
     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 startTracing(_opts, contextId) {
+    const slot = this.getSlot(contextId);
+    await slot.context.tracing.start({ screenshots: true, snapshots: true });
   }
-  async stopTracing(_opts) {
-    if (!this.context) throw new Error("No context available");
+  async stopTracing(_opts, contextId) {
+    const slot = this.getSlot(contextId);
     const tracePath = `/tmp/trace-${Date.now()}.zip`;
-    await this.context.tracing.stop({ path: tracePath });
+    await slot.context.tracing.stop({ path: tracePath });
     return {
       trace: tracePath,
       network: "",
@@ -668,4 +767,4 @@ var LocalBrowserHost = class {
 export {
   LocalBrowserHost
 };
-//# sourceMappingURL=chunk-G2X3H7AM.js.map
+//# sourceMappingURL=chunk-L26U3BST.js.map