browsirai 0.1.1 → 0.2.1

package/dist/cli/run.js

@@ -0,0 +1,728 @@
+// src/cli/run.ts
+import pc from "picocolors";
+
+// src/chrome-launcher.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import http from "http";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createConnection } from "net";
+var CHROME_PATHS = {
+  darwin: [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  ],
+  linux: [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "microsoft-edge",
+    "brave-browser"
+  ],
+  win32: [
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+  ]
+};
+function getDefaultChromeDataDir() {
+  const home = homedir();
+  switch (process.platform) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "Google", "Chrome");
+    case "win32":
+      return join(home, "AppData", "Local", "Google", "Chrome", "User Data");
+    default:
+      return join(home, ".config", "google-chrome");
+  }
+}
+function findChrome() {
+  const platform = process.platform;
+  const candidates = CHROME_PATHS[platform] ?? [];
+  for (const candidate of candidates) {
+    if (platform === "darwin" || platform === "win32") {
+      if (existsSync(candidate)) return candidate;
+    } else {
+      try {
+        const result = execSync(`which ${candidate}`, { stdio: "pipe" });
+        const path = result.toString().trim();
+        if (path) return path;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isCDPHealthy(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const req = http.get(`http://${host}:${port}/json/version`, (res) => {
+      resolve(res.statusCode === 200);
+      res.resume();
+    });
+    req.setTimeout(3e3, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on("error", () => resolve(false));
+  });
+}
+function readDevToolsActivePort(chromeDataDir) {
+  const dataDir = chromeDataDir ?? getDefaultChromeDataDir();
+  const portFile = join(dataDir, "DevToolsActivePort");
+  if (!existsSync(portFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(portFile, "utf-8");
+    const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    if (lines.length < 2) return null;
+    const port = parseInt(lines[0], 10);
+    const wsPath = lines[1];
+    if (isNaN(port) || !wsPath.startsWith("/")) return null;
+    return {
+      port,
+      wsPath,
+      wsEndpoint: `ws://127.0.0.1:${port}${wsPath}`
+    };
+  } catch {
+    return null;
+  }
+}
+function isChromeRunning() {
+  try {
+    if (process.platform === "win32") {
+      const r2 = execSync('tasklist /FI "IMAGENAME eq chrome.exe" /NH', { stdio: "pipe" }).toString();
+      return r2.includes("chrome.exe");
+    }
+    const r = execSync("pgrep -x 'Google Chrome' || pgrep -x chrome || pgrep -x chromium", { stdio: "pipe" }).toString().trim();
+    return r.length > 0;
+  } catch {
+    return false;
+  }
+}
+var SEPARATE_PORT = 9444;
+async function launchChromeWithDebugging(port = 9222, headless = false) {
+  const healthy = await isCDPHealthy(port);
+  if (healthy) {
+    const ws = await getWsEndpoint(port);
+    return { success: true, port, wsEndpoint: ws };
+  }
+  const sepHealthy = await isCDPHealthy(SEPARATE_PORT);
+  if (sepHealthy) {
+    const ws = await getWsEndpoint(SEPARATE_PORT);
+    return { success: true, port: SEPARATE_PORT, wsEndpoint: ws };
+  }
+  const chromePath = findChrome();
+  if (!chromePath) {
+    return { success: false, port, error: "Chrome not found. Install Chrome and try again." };
+  }
+  const usesSeparateInstance = isChromeRunning();
+  const targetPort = usesSeparateInstance ? SEPARATE_PORT : port;
+  const dataDir = usesSeparateInstance ? join(tmpdir(), "browsirai-normal") : void 0;
+  if (dataDir) {
+    mkdirSync(dataDir, { recursive: true });
+    syncCookiesToHeadless(dataDir);
+  }
+  const args = [
+    `--remote-debugging-port=${targetPort}`,
+    "--remote-allow-origins=*",
+    "--no-sandbox"
+  ];
+  if (dataDir) {
+    args.push(`--user-data-dir=${dataDir}`, "--no-first-run", "--no-default-browser-check", "--disable-extensions");
+  }
+  if (headless) {
+    args.push("--headless=new");
+  }
+  const child = spawn(chromePath, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  for (let i = 0; i < 75; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    const ok = await isCDPHealthy(targetPort);
+    if (ok) {
+      const ws = await getWsEndpoint(targetPort);
+      return { success: true, port: targetPort, wsEndpoint: ws };
+    }
+  }
+  return {
+    success: false,
+    port: targetPort,
+    error: "Chrome launched but CDP port not reachable after 15s. Check if another Chrome instance is blocking the profile."
+  };
+}
+async function getWsEndpoint(port) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${port}/json/version`, (res) => {
+      let body = "";
+      res.on("data", (c) => {
+        body += c.toString();
+      });
+      res.on("end", () => {
+        try {
+          const data = JSON.parse(body);
+          resolve(data.webSocketDebuggerUrl);
+        } catch {
+          resolve(void 0);
+        }
+      });
+    });
+    req.setTimeout(3e3, () => {
+      req.destroy();
+      resolve(void 0);
+    });
+    req.on("error", () => resolve(void 0));
+  });
+}
+var cookieSyncState = null;
+function syncCookiesAndTrack(destDataDir, chromeDataDir) {
+  const dataDir = chromeDataDir ?? getDefaultChromeDataDir();
+  try {
+    const localStatePath = join(dataDir, "Local State");
+    if (!existsSync(localStatePath)) return;
+    const localState = JSON.parse(readFileSync(localStatePath, "utf-8"));
+    const profileName = localState.profile?.last_used ?? "Default";
+    const srcProfileDir = join(dataDir, profileName);
+    if (!existsSync(join(srcProfileDir, "Cookies"))) return;
+    const destProfileDir = join(destDataDir, "Default");
+    mkdirSync(destProfileDir, { recursive: true });
+    const files = readdirSync(srcProfileDir).filter((f) => f.startsWith("Cookies"));
+    for (const file of files) {
+      copyFileSync(join(srcProfileDir, file), join(destProfileDir, file));
+    }
+    const mtime = statSync(join(srcProfileDir, "Cookies")).mtimeMs;
+    cookieSyncState = { profileName, cookieMtime: mtime };
+  } catch {
+  }
+}
+function syncCookiesToHeadless(headlessDataDir) {
+  syncCookiesAndTrack(headlessDataDir);
+}
+async function connectChrome(options = {}) {
+  const targetPort = options.port ?? 9222;
+  const activePort = readDevToolsActivePort();
+  if (activePort) {
+    const healthy2 = await isCDPHealthy(activePort.port);
+    if (healthy2) {
+      return {
+        success: true,
+        port: activePort.port,
+        wsEndpoint: activePort.wsEndpoint,
+        activePortFound: true
+      };
+    }
+  }
+  const healthy = await isCDPHealthy(targetPort);
+  if (healthy) {
+    return {
+      success: true,
+      port: targetPort,
+      activePortFound: false
+    };
+  }
+  if (options.autoLaunch) {
+    const launch = await launchChromeWithDebugging(targetPort, options.headless);
+    if (launch.success) {
+      return {
+        success: true,
+        port: launch.port,
+        wsEndpoint: launch.wsEndpoint,
+        activePortFound: false
+      };
+    }
+    return {
+      success: false,
+      port: targetPort,
+      activePortFound: false,
+      error: launch.error
+    };
+  }
+  return {
+    success: false,
+    port: targetPort,
+    activePortFound: activePort !== null,
+    error: "Chrome remote debugging is not enabled. Enable it at chrome://inspect/#remote-debugging"
+  };
+}
+
+// src/cdp/connection.ts
+var TIMEOUT = 15e3;
+var DAEMON_CONNECT_RETRIES = 20;
+var DAEMON_CONNECT_DELAY = 300;
+var CDPConnection = class {
+  wsUrl;
+  ws = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  closed = false;
+  reconnecting = false;
+  _connected = false;
+  // Bound listener references for cleanup
+  boundOnMessage = null;
+  boundOnClose = null;
+  boundOnError = null;
+  constructor(wsUrl) {
+    this.wsUrl = wsUrl;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /** Whether the underlying WebSocket is currently open. */
+  get isConnected() {
+    return this._connected;
+  }
+  /**
+   * Open the WebSocket connection.
+   * Resolves on the `open` event; rejects on `error`.
+   */
+  async connect() {
+    let WS = globalThis.WebSocket;
+    if (!WS) {
+      try {
+        const wsModule = await import("ws");
+        WS = wsModule.default ?? wsModule.WebSocket ?? wsModule;
+      } catch {
+        throw new Error(
+          "No WebSocket implementation found. Install the `ws` package or use Node 22+."
+        );
+      }
+    }
+    const ws = new WS(this.wsUrl);
+    this.ws = ws;
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        resolve();
+      };
+      const onError = (ev) => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        const msg = ev?.message ?? "WebSocket error";
+        reject(new Error(msg));
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+    this._connected = true;
+    this.attachListeners(ws);
+  }
+  /**
+   * Send a CDP command and await its result.
+   *
+   * @param method  CDP method (e.g. `"Runtime.evaluate"`)
+   * @param params  Optional method parameters
+   * @param options Optional timeout / sessionId overrides
+   */
+  send(method, params, options) {
+    if (this.closed || !this._connected || !this.ws) {
+      return Promise.reject(
+        new Error(`Connection closed \u2014 cannot send ${method}`)
+      );
+    }
+    const id = this.nextId++;
+    const timeout = options?.timeout ?? TIMEOUT;
+    const message = { id, method };
+    if (params !== void 0) {
+      message.params = params;
+    }
+    if (options?.sessionId !== void 0) {
+      message.sessionId = options.sessionId;
+    }
+    this.ws.send(JSON.stringify(message));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`CDP command timeout: ${method} (${timeout}ms)`));
+      }, timeout);
+      this.pending.set(id, { resolve, reject, method, timer });
+    });
+  }
+  /**
+   * Register an event handler for a CDP event or lifecycle event.
+   *
+   * CDP events are dispatched as `handler(params, { method })`.
+   * Lifecycle events: `disconnected`, `browserCrashed`, `reconnected`,
+   * `reconnectionFailed`.
+   */
+  on(event, handler) {
+    let handlers = this.eventHandlers.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(event, handlers);
+    }
+    handlers.add(handler);
+  }
+  /** Remove a previously registered event handler. */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Close the connection. Suppresses reconnection.
+   * Safe to call multiple times.
+   */
+  close() {
+    this.closed = true;
+    this._connected = false;
+    this.rejectAllPending(new Error("Connection closed"));
+    if (this.ws) {
+      this.detachListeners(this.ws);
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  /** Attach message / close / error listeners to the WebSocket. */
+  attachListeners(ws) {
+    this.boundOnMessage = (event) => {
+      const data = event?.data;
+      if (typeof data !== "string") return;
+      let msg;
+      try {
+        msg = JSON.parse(data);
+      } catch {
+        return;
+      }
+      if (msg.id !== void 0) {
+        const entry = this.pending.get(msg.id);
+        if (entry) {
+          this.pending.delete(msg.id);
+          clearTimeout(entry.timer);
+          if (msg.error) {
+            entry.reject(new Error(msg.error.message));
+          } else {
+            entry.resolve(msg.result);
+          }
+        }
+        return;
+      }
+      if (msg.method) {
+        this.emit(msg.method, msg.params ?? {}, { method: msg.method });
+      }
+    };
+    this.boundOnClose = (event) => {
+      const code = event?.code ?? 1006;
+      this._connected = false;
+      this.rejectAllPending(new Error("WebSocket disconnected \u2014 connection closed"));
+      if (code !== 1e3) {
+        this.emit("browserCrashed");
+      }
+      this.emit("disconnected");
+      if (!this.closed && code !== 1e3) {
+        this.attemptReconnection().catch(() => {
+        });
+      }
+    };
+    this.boundOnError = () => {
+    };
+    ws.addEventListener("message", this.boundOnMessage);
+    ws.addEventListener("close", this.boundOnClose);
+    ws.addEventListener("error", this.boundOnError);
+  }
+  /** Detach WebSocket listeners. */
+  detachListeners(ws) {
+    if (this.boundOnMessage) ws.removeEventListener("message", this.boundOnMessage);
+    if (this.boundOnClose) ws.removeEventListener("close", this.boundOnClose);
+    if (this.boundOnError) ws.removeEventListener("error", this.boundOnError);
+  }
+  /** Reject every pending command. */
+  rejectAllPending(error) {
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(error);
+      this.pending.delete(id);
+    }
+  }
+  /** Dispatch an event to all registered handlers. */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      try {
+        handler(...args);
+      } catch {
+      }
+    }
+  }
+  /** Attempt reconnection with retries after abnormal close. */
+  async attemptReconnection() {
+    if (this.reconnecting || this.closed) return;
+    this.reconnecting = true;
+    for (let attempt = 0; attempt < DAEMON_CONNECT_RETRIES; attempt++) {
+      if (this.closed) {
+        this.reconnecting = false;
+        return;
+      }
+      await this.delay(DAEMON_CONNECT_DELAY);
+      if (this.closed) {
+        this.reconnecting = false;
+        return;
+      }
+      try {
+        await this.connect();
+        this.reconnecting = false;
+        this.emit("reconnected");
+        return;
+      } catch {
+      }
+    }
+    this.reconnecting = false;
+    this.emit("reconnectionFailed");
+  }
+  /** Promise-based delay. */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/cli/run.ts
+function parseFlags(args) {
+  const flags = {};
+  let positionalIndex = 0;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = "true";
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1 && !/^-\d/.test(arg)) {
+      const chars = arg.slice(1);
+      if (chars.length === 1) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[chars] = next;
+          i++;
+        } else {
+          flags[chars] = "true";
+        }
+      } else {
+        for (const ch of chars) {
+          flags[ch] = "true";
+        }
+      }
+    } else {
+      flags[`_${positionalIndex}`] = arg;
+      positionalIndex++;
+    }
+  }
+  return flags;
+}
+function printResult(data) {
+  if (data === void 0 || data === null) return;
+  if (typeof data === "string") {
+    console.log(data);
+  } else if (typeof data === "object") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(String(data));
+  }
+}
+async function loadCommands() {
+  const categories = [];
+  const imports = [
+    { name: "Navigation", path: "./commands/nav.js", key: "navCommands" },
+    { name: "Observation", path: "./commands/obs.js", key: "obsCommands" },
+    { name: "Actions", path: "./commands/act.js", key: "actCommands" },
+    { name: "Network", path: "./commands/net.js", key: "netCommands" }
+  ];
+  const base = new URL(".", import.meta.url);
+  for (const entry of imports) {
+    try {
+      const url = new URL(entry.path, base).href;
+      const mod = await import(url);
+      const commands = mod[entry.key];
+      if (commands && Array.isArray(commands) && commands.length > 0) {
+        categories.push({ name: entry.name, commands });
+      }
+    } catch {
+    }
+  }
+  return categories;
+}
+function buildRegistry(categories) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const cat of categories) {
+    for (const cmd of cat.commands) {
+      registry.set(cmd.name, cmd);
+      if (cmd.aliases) {
+        for (const alias of cmd.aliases) {
+          registry.set(alias, cmd);
+        }
+      }
+    }
+  }
+  return registry;
+}
+function printHelp(categories) {
+  console.log();
+  console.log(pc.bold("browsirai") + " \u2014 Browser automation from the terminal");
+  console.log();
+  console.log(pc.dim("Usage:") + "  browsirai <command> [args...] [--flags]");
+  console.log();
+  if (categories.length === 0) {
+    console.log(
+      pc.yellow("  No commands available yet. Command modules have not been installed.")
+    );
+    console.log();
+    return;
+  }
+  for (const cat of categories) {
+    console.log(pc.cyan(pc.bold(`  ${cat.name}`)));
+    for (const cmd of cat.commands) {
+      const aliasStr = cmd.aliases?.length ? pc.dim(` (${cmd.aliases.join(", ")})`) : "";
+      const name = pc.green(cmd.name.padEnd(20));
+      console.log(`    ${name} ${pc.dim(cmd.description)}${aliasStr}`);
+    }
+    console.log();
+  }
+  console.log(pc.dim("  Examples:"));
+  console.log(pc.dim("    browsirai open example.com"));
+  console.log(pc.dim("    browsirai snapshot -i"));
+  console.log(pc.dim("    browsirai click @e5"));
+  console.log(pc.dim('    browsirai fill @e2 "hello world"'));
+  console.log(pc.dim("    browsirai press Enter"));
+  console.log(pc.dim('    browsirai eval "document.title"'));
+  console.log();
+}
+async function connectCDP() {
+  const result = await connectChrome({ autoLaunch: true });
+  if (!result.success) {
+    const msg = result.error ?? "Could not connect to Chrome via CDP.";
+    throw new Error(msg);
+  }
+  const wsUrl = result.wsEndpoint ?? `ws://127.0.0.1:${result.port}/devtools/browser`;
+  const browser = new CDPConnection(wsUrl);
+  await browser.connect();
+  const targets = await browser.send("Target.getTargets");
+  let page = targets.targetInfos.find(
+    (t) => t.type === "page" && !t.url.startsWith("chrome://")
+  ) ?? targets.targetInfos.find(
+    (t) => t.type === "page"
+  );
+  if (!page) {
+    const created = await browser.send("Target.createTarget", { url: "about:blank" });
+    page = { targetId: created.targetId, type: "page", url: "about:blank" };
+  }
+  const attached = await browser.send("Target.attachToTarget", {
+    targetId: page.targetId,
+    flatten: true
+  });
+  const sessionId = attached.sessionId;
+  const session = Object.create(browser);
+  const originalSend = browser.send.bind(browser);
+  session.send = (method, params, options) => {
+    return originalSend(method, params, {
+      ...options,
+      sessionId: options?.sessionId ?? sessionId
+    });
+  };
+  session.close = () => browser.close();
+  await Promise.all([
+    session.send("Page.enable"),
+    session.send("Runtime.enable")
+  ]).catch(() => {
+  });
+  return session;
+}
+async function runCLI(args) {
+  const commandName = args[0];
+  const remainingArgs = args.slice(1);
+  const categories = await loadCommands();
+  const registry = buildRegistry(categories);
+  if (!commandName || commandName === "--help" || commandName === "-h") {
+    printHelp(categories);
+    return;
+  }
+  const command = registry.get(commandName);
+  if (!command) {
+    console.error(
+      pc.red(`Unknown command: ${pc.bold(commandName)}`)
+    );
+    console.log();
+    console.log(
+      pc.dim("Run ") + pc.bold("browsirai --help") + pc.dim(" to see available commands.")
+    );
+    const similar = findSimilar(commandName, registry);
+    if (similar.length > 0) {
+      console.log();
+      console.log(pc.dim("Did you mean?"));
+      for (const s of similar) {
+        console.log(`  ${pc.green(s)}`);
+      }
+    }
+    console.log();
+    process.exit(1);
+  }
+  let cdp = null;
+  try {
+    cdp = await connectCDP();
+    await command.run(cdp, remainingArgs);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(pc.red(`Error: ${message}`));
+    process.exit(1);
+  } finally {
+    if (cdp?.isConnected) {
+      cdp.close();
+    }
+  }
+}
+function findSimilar(input, registry) {
+  const names = Array.from(registry.keys());
+  return names.filter((name) => {
+    return name.includes(input) || input.includes(name) || levenshtein(input, name) <= 3;
+  }).slice(0, 3);
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array(n + 1).fill(0)
+  );
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+export {
+  parseFlags,
+  printResult,
+  runCLI
+};
+//# sourceMappingURL=run.js.map