@kritchoff/agent-browser 1.0.3 → 1.0.5

package/README.md

@@ -4,6 +4,14 @@
   <strong>The Ultimate Headless Android Browser SDK & CLI for AI Agents</strong>
 </p>
 
+<p align="center">
+  <a href="https://www.npmjs.com/package/@kritchoff/agent-browser"><img src="https://img.shields.io/npm/v/@kritchoff/agent-browser.svg" alt="NPM Version" /></a>
+  <a href="https://github.com/kritagya-khanna/agent-browser/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/kritagya-khanna/agent-browser/ci.yml?branch=main" alt="Build Status" /></a>
+  <a href="https://github.com/kritagya-khanna/agent-browser/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@kritchoff/agent-browser.svg" alt="License" /></a>
+  <img src="https://img.shields.io/badge/Coverage-90%25-brightgreen.svg" alt="Coverage" />
+  <img src="https://img.shields.io/badge/TypeScript-Strict-blue.svg" alt="TypeScript Strict" />
+</p>
+
 This package provides a **Real Android Browser** (WootzApp) wrapped in a Docker container, controlled by a high-speed, Playwright-like TypeScript daemon. 
 
 It is specifically designed for AI Agents to navigate the mobile web, bypass bot detection, and generate LLM-friendly semantic trees (`AXTree`).
@@ -12,7 +20,6 @@ It is specifically designed for AI Agents to navigate the mobile web, bypass bot
 
 ## 🌟 Key Features
 
-- **Cross-Platform**: Works natively on **Windows, macOS (Intel & Apple Silicon), and Linux** using a pure Node.js Orchestrator (No WSL or bash required).
 - **Bundled CLI**: Control the browser directly from your terminal (`agent-browser start`).
 - **Zero-Config Setup**: Automatically downloads and orchestrates the required Docker containers.
 - **Hyper-Speed Warm Boots**: Uses advanced VDI Volume Mounting to boot the Android environment in **< 5 seconds** after the first run.

package/dist/cli.cjs

@@ -0,0 +1,654 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var net = __toESM(require("net"), 1);
+var import_crypto = require("crypto");
+
+// src/orchestrator.ts
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_pino = __toESM(require("pino"), 1);
+var __dirname = import_path.default.dirname((0, import_url.fileURLToPath)(importMetaUrl));
+var PROJECT_ROOT = import_path.default.resolve(__dirname, "..");
+var Orchestrator = class {
+  composeFile;
+  logger;
+  constructor(distMode, logger) {
+    this.composeFile = import_path.default.join(
+      PROJECT_ROOT,
+      distMode ? "docker-compose.sdk.yml" : "docker-compose.prod.yml"
+    );
+    this.logger = logger || (0, import_pino.default)();
+  }
+  log(msg, level = "info") {
+    switch (level) {
+      case "success":
+        this.logger.info({ sdk: true }, msg);
+        break;
+      case "warn":
+        this.logger.warn({ sdk: true }, msg);
+        break;
+      case "error":
+        this.logger.error({ sdk: true }, msg);
+        break;
+      default:
+        this.logger.info({ sdk: true }, msg);
+    }
+  }
+  runCommand(cmd, env = {}) {
+    try {
+      (0, import_child_process.execSync)(cmd, {
+        stdio: "inherit",
+        env: { ...process.env, ...env }
+      });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  getContainerId(serviceName) {
+    try {
+      const output = (0, import_child_process.execSync)(`docker compose -f "${this.composeFile}" ps -q ${serviceName}`, {
+        encoding: "utf-8"
+      });
+      return output.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  isPortMapped(containerId, port) {
+    try {
+      const output = (0, import_child_process.execSync)(`docker port "${containerId}" ${port}`, { encoding: "utf-8" });
+      return output.includes("0.0.0.0:") || output.includes(":::");
+    } catch {
+      return false;
+    }
+  }
+  async pullImagesWithRetry() {
+    if (!this.composeFile.endsWith("docker-compose.sdk.yml")) return;
+    this.log("Please wait while we get things ready...", "info");
+    const maxRetries = 10;
+    for (let count = 0; count < maxRetries; count++) {
+      if (this.runCommand(`docker compose -f "${this.composeFile}" pull`)) {
+        return;
+      }
+      this.log(
+        `Download failed/interrupted. Retrying (${count + 1}/${maxRetries}) in 10s...`,
+        "warn"
+      );
+      await new Promise((r) => setTimeout(r, 1e4));
+    }
+    this.log(
+      `Failed to download images after ${maxRetries} attempts. Check internet connection.`,
+      "error"
+    );
+    process.exit(1);
+  }
+  async hasSnapshot() {
+    try {
+      (0, import_child_process.execSync)(`docker volume inspect agent-snapshots`, { stdio: "ignore" });
+      const output = (0, import_child_process.execSync)(`docker run --rm -v agent-snapshots:/data busybox ls /data`, {
+        encoding: "utf-8"
+      });
+      return output.includes("quickboot");
+    } catch {
+      return false;
+    }
+  }
+  async start() {
+    this.log(`Initializing Agent Environment...`, "info");
+    await this.pullImagesWithRetry();
+    this.log("Cleaning up previous container state...", "info");
+    this.runCommand(`docker compose -f "${this.composeFile}" down -v --remove-orphans`);
+    const hasSnapshot = await this.hasSnapshot();
+    if (hasSnapshot) {
+      this.log("Found cached baseline snapshot. Performing HYPER-SPEED WARM BOOT...", "success");
+      const success = this.runCommand(`docker compose -f "${this.composeFile}" up -d`, {
+        EMULATOR_SNAPSHOT_NAME: "quickboot"
+      });
+      if (!success) throw new Error("Startup failed during docker compose up.");
+      const agentCont = this.getContainerId("agent-service");
+      const androidCont = this.getContainerId("android-service");
+      if (agentCont && !this.isPortMapped(agentCont, 3e3)) {
+        this.log("Port 3000 (Host 32001) is not mapped! Container config is stale.", "warn");
+        this.log("Forcing full restart to apply network settings...", "info");
+        this.runCommand(`docker compose -f "${this.composeFile}" down -v --remove-orphans`);
+        await new Promise((r) => setTimeout(r, 5e3));
+        this.runCommand(`docker compose -f "${this.composeFile}" up -d`, {
+          EMULATOR_SNAPSHOT_NAME: "quickboot"
+        });
+      }
+      if (androidCont) {
+        this.log("Rehydrating Android network connection...", "info");
+        try {
+          (0, import_child_process.execSync)(`docker exec "${androidCont}" adb shell cmd connectivity airplane-mode enable`, {
+            stdio: "ignore"
+          });
+          await new Promise((r) => setTimeout(r, 2e3));
+          (0, import_child_process.execSync)(
+            `docker exec "${androidCont}" adb shell cmd connectivity airplane-mode disable`,
+            { stdio: "ignore" }
+          );
+          await new Promise((r) => setTimeout(r, 3e3));
+        } catch (e) {
+          this.log(`Network rehydration warning: ${e}`, "warn");
+        }
+      }
+      this.log("Waiting for Daemon Connection...");
+      if (agentCont) await this.waitForLog(agentCont, "Daemon listening on TCP", 18e4);
+    } else {
+      this.log("No baseline found. Performing FIRST RUN SETUP (Cold Boot)...", "warn");
+      this.log("This will take ~60-90 seconds, but only once.", "warn");
+      const success = this.runCommand(`docker compose -f "${this.composeFile}" up -d`, {
+        EMULATOR_SNAPSHOT_NAME: ""
+      });
+      if (!success) throw new Error("Startup failed during docker compose up.");
+      let androidCont = this.getContainerId("android-service");
+      const agentCont = this.getContainerId("agent-service");
+      if (!androidCont) throw new Error("Error: Android container not found.");
+      if (agentCont && !this.isPortMapped(agentCont, 3e3)) {
+        this.log("Port 3000 (Host 32001) is not mapped! Container config is stale.", "warn");
+        this.log("Forcing full restart to apply network settings...", "info");
+        this.runCommand(`docker compose -f "${this.composeFile}" down -v --remove-orphans`);
+        await new Promise((r) => setTimeout(r, 5e3));
+        this.runCommand(`docker compose -f "${this.composeFile}" up -d`, {
+          EMULATOR_SNAPSHOT_NAME: ""
+        });
+        androidCont = this.getContainerId("android-service") || androidCont;
+      }
+      this.log("Waiting for Android OS to boot (this takes a moment)...", "info");
+      await this.waitForLog(androidCont, "Emulator boot complete");
+      this.log("Waiting for Browser Installation...", "info");
+      await this.waitForLog(androidCont, "APK installation complete");
+      this.log("Waiting for CDP Bridge...", "info");
+      await this.waitForLog(androidCont, "CDP Bridge ready");
+      this.log("Waiting for Agent Daemon Connection...");
+      if (agentCont) await this.waitForLog(agentCont, "Daemon listening on TCP");
+      this.log("Saving emulator state (quickboot)...", "info");
+      const saved = this.runCommand(
+        `docker exec "${androidCont}" adb emu avd snapshot save quickboot`
+      );
+      if (saved) {
+        this.log("Snapshot saved to host volume.", "success");
+        this.log("Setup Complete! Future runs will launch instantly.", "success");
+      } else {
+        throw new Error("Failed to save snapshot inside emulator.");
+      }
+    }
+  }
+  async stop() {
+    this.log("Stopping environment...", "info");
+    this.runCommand(`docker compose -f "${this.composeFile}" down -v --remove-orphans`);
+    this.log("Environment cleaned and stopped.", "success");
+  }
+  async reset() {
+    this.log("Performing Fast Browser Reset...", "info");
+    const androidCont = this.getContainerId("android-service");
+    if (!androidCont) {
+      this.log("Android container not running.", "error");
+      return;
+    }
+    this.log("Initiating fast reset (userspace reboot)...", "info");
+    try {
+      (0, import_child_process.execSync)(`docker exec "${androidCont}" adb shell reboot userspace`, { stdio: "ignore" });
+    } catch {
+    }
+    this.log("Waiting for device to come online...", "info");
+    const start = Date.now();
+    let online = false;
+    while (Date.now() - start < 3e4) {
+      try {
+        const state = (0, import_child_process.execSync)(`docker exec "${androidCont}" adb get-state`, {
+          encoding: "utf-8"
+        }).trim();
+        if (state === "device") {
+          (0, import_child_process.execSync)(`docker exec "${androidCont}" adb shell echo ok`, { stdio: "ignore" });
+          online = true;
+          break;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    if (!online) throw new Error("Timeout waiting for device after reboot");
+    this.log("Device online", "success");
+    this.log("Waiting for browser CDP...", "info");
+    const cdpStart = Date.now();
+    let cdpReady = false;
+    while (Date.now() - cdpStart < 3e4) {
+      try {
+        (0, import_child_process.execSync)(
+          `docker exec "${androidCont}" curl -s --connect-timeout 2 http://localhost:9224/json/version`,
+          { stdio: "ignore" }
+        );
+        cdpReady = true;
+        break;
+      } catch {
+        if (Date.now() - cdpStart > 15e3) {
+          try {
+            (0, import_child_process.execSync)(
+              `docker exec "${androidCont}" adb shell am start -n com.wootzapp.web/com.aspect.chromium.ChromiumMain -a android.intent.action.VIEW -d 'about:blank'`,
+              { stdio: "ignore" }
+            );
+          } catch {
+          }
+        }
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    if (!cdpReady) throw new Error("Timeout waiting for CDP");
+    this.log("Fast reset complete!", "success");
+  }
+  waitForLog(container, pattern, timeoutMs = 12e4) {
+    return new Promise((resolve, reject) => {
+      const start = Date.now();
+      const tail = (0, import_child_process.spawn)("docker", ["logs", "-f", container]);
+      const timer = setTimeout(() => {
+        tail.kill();
+        reject(new Error(`Timeout waiting for log pattern "${pattern}" in container ${container}`));
+      }, timeoutMs);
+      tail.stdout.on("data", (data) => {
+        if (data.toString().includes(pattern)) {
+          clearTimeout(timer);
+          tail.kill();
+          resolve();
+        }
+      });
+      tail.stderr.on("data", (data) => {
+        if (data.toString().includes(pattern)) {
+          clearTimeout(timer);
+          tail.kill();
+          resolve();
+        }
+      });
+      tail.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+};
+
+// src/index.ts
+var import_zod = require("zod");
+var import_pino2 = __toESM(require("pino"), 1);
+var DAEMON_PORT = 32001;
+var WootzConnectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WootzConnectionError";
+  }
+};
+var WootzTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WootzTimeoutError";
+  }
+};
+var WootzValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WootzValidationError";
+  }
+};
+var AgentOptionsSchema = import_zod.z.object({
+  dist: import_zod.z.boolean().optional().default(true),
+  logLevel: import_zod.z.enum(["debug", "info", "warn", "error", "silent"]).optional().default("info")
+}).passthrough();
+var WootzAgent = class {
+  options;
+  orchestrator;
+  logger;
+  /**
+   * Creates a new instance of the WootzAgent.
+   * @param options Configuration options.
+   * @throws {WootzValidationError} If the provided options do not match the expected schema.
+   */
+  constructor(options = {}) {
+    const parsedOptions = AgentOptionsSchema.safeParse(options);
+    if (!parsedOptions.success) {
+      throw new WootzValidationError(`Invalid agent options: ${parsedOptions.error.message}`);
+    }
+    this.options = parsedOptions.data;
+    this.logger = (0, import_pino2.default)({
+      level: this.options.logLevel,
+      transport: this.options.logLevel !== "silent" ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "HH:MM:ss Z",
+          ignore: "pid,hostname"
+        }
+      } : void 0
+    });
+    this.orchestrator = new Orchestrator(this.options.dist, this.logger);
+  }
+  // --- Lifecycle Management (Infrastructure) ---
+  /**
+   * Starts the underlying orchestrator and waits for the browser daemon to be ready.
+   * @throws {WootzTimeoutError} If the daemon fails to become available within the timeout.
+   */
+  async start() {
+    await this.orchestrator.start();
+    await this.waitForDaemon();
+  }
+  /**
+   * Polls the daemon port until it accepts connections.
+   * @param timeoutMs The maximum amount of time (in ms) to wait for the daemon.
+   */
+  async waitForDaemon(timeoutMs = 18e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      try {
+        await this.sendCommand({ action: "tab_list" });
+        return;
+      } catch (e) {
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    }
+    throw new WootzTimeoutError(
+      `Timed out waiting for Agent Daemon on port ${DAEMON_PORT} after ${timeoutMs / 1e3}s`
+    );
+  }
+  /**
+   * Stops the orchestrator and cleans up resources.
+   */
+  async stop() {
+    await this.orchestrator.stop();
+  }
+  /**
+   * Resets the environment completely.
+   */
+  async reset() {
+    await this.orchestrator.reset();
+  }
+  // --- Core Browser Actions (Direct Daemon) ---
+  /**
+   * Navigates the current tab to a specified URL.
+   * @param url The URL to navigate to.
+   * @param waitUntil The load state to wait for ('load', 'domcontentloaded', 'networkidle').
+   */
+  async navigate(url, waitUntil = "load") {
+    return await this.sendCommand({ action: "navigate", url, waitUntil });
+  }
+  /**
+   * Clicks on an element matching the given selector.
+   * @param selector The CSS or semantic selector of the element to click.
+   */
+  async click(selector) {
+    return await this.sendCommand({ action: "click", selector });
+  }
+  /**
+   * Double-clicks on an element matching the given selector.
+   * @param selector The CSS or semantic selector.
+   */
+  async doubleClick(selector) {
+    return await this.sendCommand({ action: "dblclick", selector });
+  }
+  /**
+   * Types text into a form field character by character.
+   * @param selector The CSS or semantic selector of the input field.
+   * @param text The text to type.
+   * @param delay Delay between keystrokes in milliseconds.
+   */
+  async type(selector, text, delay) {
+    return await this.sendCommand({ action: "type", selector, text, delay });
+  }
+  /**
+   * Fills an input field directly with a value (faster than type).
+   * @param selector The CSS or semantic selector of the input field.
+   * @param value The value to fill.
+   */
+  async fill(selector, value) {
+    return await this.sendCommand({ action: "fill", selector, value });
+  }
+  async check(selector) {
+    return await this.sendCommand({ action: "check", selector });
+  }
+  async uncheck(selector) {
+    return await this.sendCommand({ action: "uncheck", selector });
+  }
+  async hover(selector) {
+    return await this.sendCommand({ action: "hover", selector });
+  }
+  async focus(selector) {
+    return await this.sendCommand({ action: "focus", selector });
+  }
+  async press(key, selector) {
+    return await this.sendCommand({ action: "press", key, selector });
+  }
+  async selectOption(selector, value) {
+    return await this.sendCommand({ action: "select", selector, values: value });
+  }
+  // --- Introspection & State ---
+  /**
+   * Captures the full DOM/AXTree snapshot of the current page.
+   * @returns A string representation of the interactive accessibility tree.
+   */
+  async snapshot() {
+    const result = await this.sendCommand({ action: "snapshot" }, true);
+    return result.snapshot || "";
+  }
+  async innerText(selector) {
+    const res = await this.sendCommand({ action: "innertext", selector }, true);
+    return res.text;
+  }
+  async innerHTML(selector) {
+    const res = await this.sendCommand({ action: "innerhtml", selector }, true);
+    return res.html;
+  }
+  async getAttribute(selector, attribute) {
+    const res = await this.sendCommand({ action: "getattribute", selector, attribute }, true);
+    return res.value;
+  }
+  async inputValue(selector) {
+    const res = await this.sendCommand({ action: "inputvalue", selector }, true);
+    return res.value;
+  }
+  async isVisible(selector) {
+    const res = await this.sendCommand({ action: "isvisible", selector }, true);
+    return res.visible;
+  }
+  async isEnabled(selector) {
+    const res = await this.sendCommand({ action: "isenabled", selector }, true);
+    return res.enabled;
+  }
+  async isChecked(selector) {
+    const res = await this.sendCommand({ action: "ischecked", selector }, true);
+    return res.checked;
+  }
+  // --- Waiting & Navigation ---
+  async waitForSelector(selector, state = "visible", timeout) {
+    return await this.sendCommand({ action: "wait", selector, state, timeout });
+  }
+  async waitForTimeout(ms) {
+    return await this.sendCommand({ action: "wait", timeout: ms });
+  }
+  async waitForLoadState(state = "load") {
+    return await this.sendCommand({ action: "waitforloadstate", state });
+  }
+  async reload() {
+    return await this.sendCommand({ action: "reload" });
+  }
+  async goBack() {
+    return await this.sendCommand({ action: "back" });
+  }
+  async goForward() {
+    return await this.sendCommand({ action: "forward" });
+  }
+  // --- Semantic Locators ---
+  async getByRole(role, name, _exact = false) {
+    throw new Error(
+      "Locator builders (getByRole) are not fully supported in stateless mode yet. Use standard selectors."
+    );
+  }
+  // --- Utilities ---
+  /**
+   * Captures a screenshot of the current page.
+   * @param path Optional file path to save the screenshot.
+   */
+  async screenshot(path2) {
+    const res = await this.sendCommand({ action: "screenshot", path: path2 }, true);
+    return res.path;
+  }
+  async scroll(x, y) {
+    return await this.sendCommand({ action: "scroll", x, y });
+  }
+  async evaluate(script) {
+    const res = await this.sendCommand({ action: "evaluate", script }, true);
+    return res.result;
+  }
+  // --- Tab Management ---
+  async newTab(url) {
+    return await this.sendCommand({ action: "tab_new", url });
+  }
+  async switchTab(index) {
+    return await this.sendCommand({ action: "tab_switch", index });
+  }
+  async closeTab(index) {
+    return await this.sendCommand({ action: "tab_close", index });
+  }
+  async listTabs() {
+    const res = await this.sendCommand({ action: "tab_list" }, true);
+    return res.tabs;
+  }
+  // --- Generic Execution ---
+  async command(action, ...args2) {
+    const cmd = { action };
+    if (action === "open" || action === "navigate") {
+      cmd.action = "navigate";
+      cmd.url = args2[0];
+    } else if (action === "click") {
+      cmd.selector = args2[0];
+    } else if (action === "type") {
+      cmd.selector = args2[0];
+      cmd.text = args2[1];
+    } else if (action === "press") {
+      cmd.key = args2[0];
+    } else if (action === "scroll") {
+      cmd.x = parseInt(args2[0] || "0");
+      cmd.y = parseInt(args2[1] || "0");
+    } else if (action === "wait") {
+      if (/^\d+$/.test(args2[0])) cmd.timeout = parseInt(args2[0]);
+      else cmd.selector = args2[0];
+    } else {
+      if (args2[0]) cmd.selector = args2[0];
+      if (args2[1]) cmd.text = args2[1] || args2[1];
+    }
+    const res = await this.sendCommand(cmd, true);
+    if (typeof res === "object") {
+      if (res.text) return res.text;
+      if (res.url) return res.url;
+      if (res.snapshot) return res.snapshot;
+      return JSON.stringify(res);
+    }
+    return String(res);
+  }
+  sendCommand(command2, returnData = false) {
+    return new Promise((resolve, reject) => {
+      if (!command2.id) command2.id = (0, import_crypto.randomUUID)();
+      const client = new net.Socket();
+      client.connect(DAEMON_PORT, "127.0.0.1", () => {
+        client.write(JSON.stringify(command2) + "\n");
+      });
+      let responseBuffer = "";
+      client.on("data", (data) => {
+        responseBuffer += data.toString();
+        if (responseBuffer.includes("\n")) {
+          client.end();
+        }
+      });
+      client.on("end", () => {
+        try {
+          const response = JSON.parse(responseBuffer.trim());
+          if (response.success) {
+            resolve(returnData ? response.data : "OK");
+          } else {
+            reject(new Error(response.error || "Unknown error"));
+          }
+        } catch (e) {
+          reject(new Error(`Invalid response from daemon: ${responseBuffer}`));
+        }
+      });
+      client.on("error", (err) => {
+        reject(new WootzConnectionError(`Failed to connect to agent daemon (is it running?): ${err.message}`));
+      });
+    });
+  }
+};
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args.find((arg) => !arg.startsWith("-"));
+if (!command || command === "help") {
+  console.log(`
+WootzApp Agent Browser CLI
+
+Usage:
+  agent-browser start      Initialize and start the environment
+  agent-browser stop       Stop the environment
+  agent-browser reset      Fast reset the browser state
+  agent-browser <cmd>      Run an agent command (e.g. open https://google.com)
+
+Options:
+  --dist                   Use pre-built images from Docker Hub (default)
+  --local                  Build images locally from source
+`);
+  process.exit(0);
+}
+var isLocal = args.includes("--local");
+var filteredArgs = args.filter((arg) => arg !== "--local" && arg !== "--dist");
+var agent = new WootzAgent({ dist: !isLocal });
+async function main() {
+  try {
+    switch (command) {
+      case "start":
+        await agent.start();
+        break;
+      case "stop":
+        await agent.stop();
+        break;
+      case "reset":
+        await agent.reset();
+        break;
+      default:
+        const result = await agent.command(command, ...filteredArgs.slice(1));
+        console.log(result);
+        break;
+    }
+  } catch (error) {
+    console.error(`
+\u274C Error: ${error.message || error}`);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.cjs.map