@hasna/browser 0.0.1

package/dist/server/index.js

@@ -0,0 +1,1580 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/types/index.ts
+var BrowserError, SessionNotFoundError, EngineNotAvailableError, NavigationError, ElementNotFoundError, RecordingNotFoundError, AgentNotFoundError, ProjectNotFoundError;
+var init_types = __esm(() => {
+  BrowserError = class BrowserError extends Error {
+    code;
+    retryable;
+    constructor(message, code = "BROWSER_ERROR", retryable = false) {
+      super(message);
+      this.code = code;
+      this.retryable = retryable;
+      this.name = "BrowserError";
+    }
+  };
+  SessionNotFoundError = class SessionNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Session not found: ${id}`, "SESSION_NOT_FOUND", false);
+      this.name = "SessionNotFoundError";
+    }
+  };
+  EngineNotAvailableError = class EngineNotAvailableError extends BrowserError {
+    constructor(engine, reason) {
+      super(`Engine '${engine}' is not available${reason ? `: ${reason}` : ""}`, "ENGINE_NOT_AVAILABLE", false);
+      this.name = "EngineNotAvailableError";
+    }
+  };
+  NavigationError = class NavigationError extends BrowserError {
+    constructor(url, reason) {
+      super(`Navigation to '${url}' failed${reason ? `: ${reason}` : ""}`, "NAVIGATION_ERROR", true);
+      this.name = "NavigationError";
+    }
+  };
+  ElementNotFoundError = class ElementNotFoundError extends BrowserError {
+    constructor(selector) {
+      super(`Element not found: ${selector}`, "ELEMENT_NOT_FOUND", false);
+      this.name = "ElementNotFoundError";
+    }
+  };
+  RecordingNotFoundError = class RecordingNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Recording not found: ${id}`, "RECORDING_NOT_FOUND", false);
+      this.name = "RecordingNotFoundError";
+    }
+  };
+  AgentNotFoundError = class AgentNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Agent not found: ${id}`, "AGENT_NOT_FOUND", false);
+      this.name = "AgentNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Project not found: ${id}`, "PROJECT_NOT_FOUND", false);
+      this.name = "ProjectNotFoundError";
+    }
+  };
+});
+
+// src/db/schema.ts
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+function getDataDir() {
+  return process.env["BROWSER_DATA_DIR"] ?? join(homedir(), ".browser");
+}
+function getDatabase(path) {
+  const resolvedPath = path ?? process.env["BROWSER_DB_PATH"] ?? join(getDataDir(), "browser.db");
+  if (_db && _dbPath === resolvedPath)
+    return _db;
+  if (_db) {
+    try {
+      _db.close();
+    } catch {}
+    _db = null;
+  }
+  mkdirSync(join(resolvedPath, ".."), { recursive: true });
+  _db = new Database(resolvedPath);
+  _dbPath = resolvedPath;
+  _db.exec("PRAGMA journal_mode=WAL;");
+  _db.exec("PRAGMA foreign_keys=ON;");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version   INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  const applied = new Set(db.query("SELECT version FROM schema_migrations").all().map((r) => r.version));
+  const migrations = [
+    {
+      version: 1,
+      sql: `
+        CREATE TABLE IF NOT EXISTS projects (
+          id          TEXT PRIMARY KEY,
+          name        TEXT NOT NULL UNIQUE,
+          path        TEXT NOT NULL,
+          description TEXT,
+          created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS agents (
+          id          TEXT PRIMARY KEY,
+          name        TEXT NOT NULL,
+          description TEXT,
+          session_id  TEXT,
+          project_id  TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          working_dir TEXT,
+          last_seen   TEXT NOT NULL DEFAULT (datetime('now')),
+          created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS heartbeats (
+          id         TEXT PRIMARY KEY,
+          agent_id   TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+          session_id TEXT,
+          timestamp  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          id         TEXT PRIMARY KEY,
+          engine     TEXT NOT NULL,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          agent_id   TEXT REFERENCES agents(id) ON DELETE SET NULL,
+          start_url  TEXT,
+          status     TEXT NOT NULL DEFAULT 'active',
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          closed_at  TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS snapshots (
+          id              TEXT PRIMARY KEY,
+          session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          url             TEXT NOT NULL,
+          title           TEXT,
+          html            TEXT,
+          screenshot_path TEXT,
+          timestamp       TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS network_log (
+          id               TEXT PRIMARY KEY,
+          session_id       TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          method           TEXT NOT NULL,
+          url              TEXT NOT NULL,
+          status_code      INTEGER,
+          request_headers  TEXT,
+          response_headers TEXT,
+          request_body     TEXT,
+          body_size        INTEGER,
+          duration_ms      INTEGER,
+          resource_type    TEXT,
+          timestamp        TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS console_log (
+          id          TEXT PRIMARY KEY,
+          session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          level       TEXT NOT NULL DEFAULT 'log',
+          message     TEXT NOT NULL,
+          source      TEXT,
+          line_number INTEGER,
+          timestamp   TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS recordings (
+          id         TEXT PRIMARY KEY,
+          name       TEXT NOT NULL,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          start_url  TEXT,
+          steps      TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS crawl_results (
+          id         TEXT PRIMARY KEY,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          start_url  TEXT NOT NULL,
+          depth      INTEGER NOT NULL DEFAULT 1,
+          pages      TEXT NOT NULL DEFAULT '[]',
+          links      TEXT NOT NULL DEFAULT '[]',
+          errors     TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        CREATE INDEX IF NOT EXISTS idx_snapshots_session ON snapshots(session_id);
+        CREATE INDEX IF NOT EXISTS idx_network_log_session ON network_log(session_id);
+        CREATE INDEX IF NOT EXISTS idx_console_log_session ON console_log(session_id);
+        CREATE INDEX IF NOT EXISTS idx_agents_project ON agents(project_id);
+        CREATE INDEX IF NOT EXISTS idx_heartbeats_agent ON heartbeats(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_recordings_project ON recordings(project_id);
+        CREATE INDEX IF NOT EXISTS idx_crawl_results_project ON crawl_results(project_id);
+      `
+    }
+  ];
+  for (const m of migrations) {
+    if (!applied.has(m.version)) {
+      db.transaction(() => {
+        db.exec(m.sql);
+        db.prepare("INSERT INTO schema_migrations (version) VALUES (?)").run(m.version);
+      })();
+    }
+  }
+}
+var _db = null, _dbPath = null;
+var init_schema = () => {};
+
+// src/db/recordings.ts
+var exports_recordings = {};
+__export(exports_recordings, {
+  updateRecording: () => updateRecording,
+  listRecordings: () => listRecordings,
+  getRecording: () => getRecording,
+  deleteRecording: () => deleteRecording,
+  createRecording: () => createRecording
+});
+import { randomUUID as randomUUID5 } from "crypto";
+function deserialize2(row) {
+  return {
+    ...row,
+    project_id: row.project_id ?? undefined,
+    start_url: row.start_url ?? undefined,
+    steps: JSON.parse(row.steps)
+  };
+}
+function createRecording(data) {
+  const db = getDatabase();
+  const id = randomUUID5();
+  db.prepare("INSERT INTO recordings (id, name, project_id, start_url, steps) VALUES (?, ?, ?, ?, ?)").run(id, data.name, data.project_id ?? null, data.start_url ?? null, JSON.stringify(data.steps ?? []));
+  return getRecording(id);
+}
+function getRecording(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM recordings WHERE id = ?").get(id);
+  if (!row)
+    throw new RecordingNotFoundError(id);
+  return deserialize2(row);
+}
+function listRecordings(projectId) {
+  const db = getDatabase();
+  const rows = projectId ? db.query("SELECT * FROM recordings WHERE project_id = ? ORDER BY created_at DESC").all(projectId) : db.query("SELECT * FROM recordings ORDER BY created_at DESC").all();
+  return rows.map(deserialize2);
+}
+function updateRecording(id, data) {
+  const db = getDatabase();
+  const fields = [];
+  const values = [];
+  if (data.name !== undefined) {
+    fields.push("name = ?");
+    values.push(data.name);
+  }
+  if (data.steps !== undefined) {
+    fields.push("steps = ?");
+    values.push(JSON.stringify(data.steps));
+  }
+  if (data.start_url !== undefined) {
+    fields.push("start_url = ?");
+    values.push(data.start_url ?? null);
+  }
+  if (fields.length === 0)
+    return getRecording(id);
+  values.push(id);
+  db.prepare(`UPDATE recordings SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getRecording(id);
+}
+function deleteRecording(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM recordings WHERE id = ?").run(id);
+}
+var init_recordings = __esm(() => {
+  init_schema();
+  init_types();
+});
+
+// src/db/agents.ts
+var exports_agents = {};
+__export(exports_agents, {
+  updateAgent: () => updateAgent,
+  registerAgent: () => registerAgent,
+  listAgents: () => listAgents,
+  heartbeat: () => heartbeat,
+  getAgentByName: () => getAgentByName,
+  getAgent: () => getAgent,
+  deleteAgent: () => deleteAgent,
+  cleanStaleAgents: () => cleanStaleAgents
+});
+import { randomUUID as randomUUID6 } from "crypto";
+function registerAgent(name, opts = {}) {
+  const db = getDatabase();
+  const existing = db.query("SELECT * FROM agents WHERE name = ?").get(name);
+  if (existing) {
+    db.prepare("UPDATE agents SET last_seen = datetime('now'), session_id = ?, project_id = ?, working_dir = ? WHERE name = ?").run(opts.sessionId ?? existing.session_id ?? null, opts.projectId ?? existing.project_id ?? null, opts.workingDir ?? existing.working_dir ?? null, name);
+    return getAgentByName(name);
+  }
+  const id = randomUUID6();
+  db.prepare("INSERT INTO agents (id, name, description, session_id, project_id, working_dir) VALUES (?, ?, ?, ?, ?, ?)").run(id, name, opts.description ?? null, opts.sessionId ?? null, opts.projectId ?? null, opts.workingDir ?? null);
+  return getAgent(id);
+}
+function heartbeat(agentId) {
+  const db = getDatabase();
+  const agent = db.query("SELECT * FROM agents WHERE id = ?").get(agentId);
+  if (!agent)
+    throw new AgentNotFoundError(agentId);
+  db.prepare("UPDATE agents SET last_seen = datetime('now') WHERE id = ?").run(agentId);
+  db.prepare("INSERT INTO heartbeats (id, agent_id, session_id) VALUES (?, ?, ?)").run(randomUUID6(), agentId, agent.session_id ?? null);
+}
+function getAgent(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM agents WHERE id = ?").get(id);
+  if (!row)
+    throw new AgentNotFoundError(id);
+  return row;
+}
+function getAgentByName(name) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM agents WHERE name = ?").get(name) ?? null;
+}
+function listAgents(projectId) {
+  const db = getDatabase();
+  if (projectId) {
+    return db.query("SELECT * FROM agents WHERE project_id = ? ORDER BY last_seen DESC").all(projectId);
+  }
+  return db.query("SELECT * FROM agents ORDER BY last_seen DESC").all();
+}
+function updateAgent(id, data) {
+  const db = getDatabase();
+  const fields = [];
+  const values = [];
+  if (data.name !== undefined) {
+    fields.push("name = ?");
+    values.push(data.name ?? null);
+  }
+  if (data.description !== undefined) {
+    fields.push("description = ?");
+    values.push(data.description ?? null);
+  }
+  if (data.session_id !== undefined) {
+    fields.push("session_id = ?");
+    values.push(data.session_id ?? null);
+  }
+  if (data.project_id !== undefined) {
+    fields.push("project_id = ?");
+    values.push(data.project_id ?? null);
+  }
+  if (data.working_dir !== undefined) {
+    fields.push("working_dir = ?");
+    values.push(data.working_dir ?? null);
+  }
+  if (fields.length === 0)
+    return getAgent(id);
+  values.push(id);
+  db.prepare(`UPDATE agents SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getAgent(id);
+}
+function deleteAgent(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM agents WHERE id = ?").run(id);
+}
+function cleanStaleAgents(thresholdMs) {
+  const db = getDatabase();
+  const cutoff = new Date(Date.now() - thresholdMs).toISOString().replace("T", " ").split(".")[0];
+  const result = db.prepare("DELETE FROM agents WHERE last_seen < ?").run(cutoff);
+  return result.changes;
+}
+var init_agents = __esm(() => {
+  init_schema();
+  init_types();
+});
+
+// src/db/snapshots.ts
+var exports_snapshots = {};
+__export(exports_snapshots, {
+  listSnapshots: () => listSnapshots,
+  getSnapshot: () => getSnapshot,
+  deleteSnapshotsBySession: () => deleteSnapshotsBySession,
+  deleteSnapshot: () => deleteSnapshot,
+  createSnapshot: () => createSnapshot
+});
+import { randomUUID as randomUUID8 } from "crypto";
+function createSnapshot(data) {
+  const db = getDatabase();
+  const id = randomUUID8();
+  db.prepare("INSERT INTO snapshots (id, session_id, url, title, html, screenshot_path) VALUES (?, ?, ?, ?, ?, ?)").run(id, data.session_id, data.url, data.title ?? null, data.html ?? null, data.screenshot_path ?? null);
+  return getSnapshot(id);
+}
+function getSnapshot(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM snapshots WHERE id = ?").get(id) ?? null;
+}
+function listSnapshots(sessionId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM snapshots WHERE session_id = ? ORDER BY timestamp DESC").all(sessionId);
+}
+function deleteSnapshot(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM snapshots WHERE id = ?").run(id);
+}
+function deleteSnapshotsBySession(sessionId) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM snapshots WHERE session_id = ?").run(sessionId);
+}
+var init_snapshots = __esm(() => {
+  init_schema();
+});
+
+// src/server/index.ts
+import { join as join3 } from "path";
+import { existsSync } from "fs";
+
+// src/lib/session.ts
+init_types();
+init_types();
+
+// src/db/sessions.ts
+init_schema();
+init_types();
+import { randomUUID } from "crypto";
+function createSession(data) {
+  const db = getDatabase();
+  const id = randomUUID();
+  db.prepare("INSERT INTO sessions (id, engine, project_id, agent_id, start_url) VALUES (?, ?, ?, ?, ?)").run(id, data.engine, data.projectId ?? null, data.agentId ?? null, data.startUrl ?? null);
+  return getSession(id);
+}
+function getSession(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  if (!row)
+    throw new SessionNotFoundError(id);
+  return row;
+}
+function listSessions(filter) {
+  const db = getDatabase();
+  const conditions = [];
+  const values = [];
+  if (filter?.status) {
+    conditions.push("status = ?");
+    values.push(filter.status);
+  }
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    values.push(filter.projectId);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db.query(`SELECT * FROM sessions ${where} ORDER BY created_at DESC`).all(...values);
+}
+function updateSessionStatus(id, status) {
+  const db = getDatabase();
+  const closedAt = status === "closed" || status === "error" ? "datetime('now')" : "NULL";
+  db.prepare(`UPDATE sessions SET status = ?, closed_at = ${closedAt === "NULL" ? "NULL" : "(datetime('now'))"} WHERE id = ?`).run(status, id);
+  return getSession(id);
+}
+function closeSession(id) {
+  return updateSessionStatus(id, "closed");
+}
+
+// src/engines/playwright.ts
+init_types();
+import { chromium } from "playwright";
+var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+async function launchPlaywright(options) {
+  try {
+    return await chromium.launch({
+      headless: options?.headless ?? true,
+      executablePath: options?.executablePath
+    });
+  } catch (err) {
+    throw new BrowserError(`Failed to launch Playwright browser: ${err instanceof Error ? err.message : String(err)}`, "PLAYWRIGHT_LAUNCH_FAILED", true);
+  }
+}
+async function getPage(browser, options) {
+  const context = await browser.newContext({
+    viewport: options?.viewport ?? DEFAULT_VIEWPORT,
+    userAgent: options?.userAgent,
+    locale: options?.locale
+  });
+  return context.newPage();
+}
+async function closeBrowser(browser) {
+  try {
+    await browser.close();
+  } catch {}
+}
+
+// src/engines/lightpanda.ts
+init_types();
+import { execSync, spawn } from "child_process";
+import { chromium as chromium2 } from "playwright";
+var DEFAULT_LIGHTPANDA_PORT = 9222;
+var LIGHTPANDA_BINARY = process.env["LIGHTPANDA_BINARY"] ?? "lightpanda";
+function isLightpandaAvailable() {
+  try {
+    execSync(`which ${LIGHTPANDA_BINARY}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    const paths = [
+      "/usr/local/bin/lightpanda",
+      "/usr/bin/lightpanda",
+      `${process.env["HOME"]}/.browser/bin/lightpanda`
+    ];
+    return paths.some((p) => {
+      try {
+        execSync(`test -x ${p}`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+}
+function getLightpandaBinaryPath() {
+  if (process.env["LIGHTPANDA_BINARY"])
+    return process.env["LIGHTPANDA_BINARY"];
+  const paths = [
+    "lightpanda",
+    "/usr/local/bin/lightpanda",
+    "/usr/bin/lightpanda",
+    `${process.env["HOME"]}/.browser/bin/lightpanda`
+  ];
+  for (const p of paths) {
+    try {
+      execSync(`which ${p}`, { stdio: "ignore" });
+      return p;
+    } catch {
+      try {
+        execSync(`test -x ${p}`, { stdio: "ignore" });
+        return p;
+      } catch {
+        continue;
+      }
+    }
+  }
+  throw new EngineNotAvailableError("lightpanda", "binary not found. Run: browser install-browser --engine lightpanda");
+}
+var _lpProcess = null;
+async function launchLightpanda(port) {
+  if (_lpProcess)
+    return _lpProcess;
+  if (!isLightpandaAvailable()) {
+    throw new EngineNotAvailableError("lightpanda", "binary not found. Run: browser install-browser --engine lightpanda");
+  }
+  const usePort = port ?? DEFAULT_LIGHTPANDA_PORT;
+  const binary = getLightpandaBinaryPath();
+  const proc = spawn(binary, ["--cdp-host", "127.0.0.1", "--cdp-port", String(usePort)], {
+    stdio: "ignore",
+    detached: false
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new BrowserError("Lightpanda startup timeout", "LIGHTPANDA_TIMEOUT")), 5000);
+    const check = setInterval(async () => {
+      try {
+        const resp = await fetch(`http://127.0.0.1:${usePort}/json/version`);
+        if (resp.ok) {
+          clearInterval(check);
+          clearTimeout(timeout);
+          resolve();
+        }
+      } catch {}
+    }, 100);
+    proc.on("error", (err) => {
+      clearInterval(check);
+      clearTimeout(timeout);
+      reject(new BrowserError(`Lightpanda failed to start: ${err.message}`, "LIGHTPANDA_ERROR"));
+    });
+  });
+  _lpProcess = {
+    process: proc,
+    port: usePort,
+    wsUrl: `ws://127.0.0.1:${usePort}`
+  };
+  return _lpProcess;
+}
+async function connectLightpanda(port) {
+  const lp = await launchLightpanda(port);
+  try {
+    const resp = await fetch(`http://127.0.0.1:${lp.port}/json/version`);
+    const info = await resp.json();
+    const wsUrl = info.webSocketDebuggerUrl ?? `ws://127.0.0.1:${lp.port}`;
+    return await chromium2.connectOverCDP(wsUrl);
+  } catch (err) {
+    throw new BrowserError(`Failed to connect to Lightpanda: ${err instanceof Error ? err.message : String(err)}`, "LIGHTPANDA_CONNECT_FAILED");
+  }
+}
+
+// src/engines/selector.ts
+init_types();
+var ENGINE_MAP = {
+  ["scrape" /* SCRAPE */]: "lightpanda",
+  ["extract_links" /* EXTRACT_LINKS */]: "lightpanda",
+  ["status_check" /* STATUS_CHECK */]: "lightpanda",
+  ["form_fill" /* FORM_FILL */]: "playwright",
+  ["spa_navigate" /* SPA_NAVIGATE */]: "playwright",
+  ["screenshot" /* SCREENSHOT */]: "playwright",
+  ["auth_flow" /* AUTH_FLOW */]: "playwright",
+  ["multi_tab" /* MULTI_TAB */]: "playwright",
+  ["record_replay" /* RECORD_REPLAY */]: "playwright",
+  ["network_monitor" /* NETWORK_MONITOR */]: "cdp",
+  ["har_capture" /* HAR_CAPTURE */]: "cdp",
+  ["perf_profile" /* PERF_PROFILE */]: "cdp",
+  ["script_inject" /* SCRIPT_INJECT */]: "cdp",
+  ["coverage" /* COVERAGE */]: "cdp"
+};
+function selectEngine(useCase, explicit) {
+  if (explicit && explicit !== "auto")
+    return explicit;
+  const preferred = ENGINE_MAP[useCase];
+  if (preferred === "lightpanda" && !isLightpandaAvailable()) {
+    return "playwright";
+  }
+  return preferred;
+}
+
+// src/lib/session.ts
+var handles = new Map;
+async function createSession2(opts = {}) {
+  const engine = opts.engine === "auto" || !opts.engine ? selectEngine(opts.useCase ?? "spa_navigate" /* SPA_NAVIGATE */, opts.engine) : opts.engine;
+  const resolvedEngine = engine === "auto" ? "playwright" : engine;
+  let browser;
+  let page;
+  if (resolvedEngine === "lightpanda") {
+    browser = await connectLightpanda();
+    const context = await browser.newContext({ viewport: opts.viewport ?? { width: 1280, height: 720 } });
+    page = await context.newPage();
+  } else {
+    browser = await launchPlaywright({
+      headless: opts.headless ?? true,
+      viewport: opts.viewport,
+      userAgent: opts.userAgent
+    });
+    page = await getPage(browser, {
+      viewport: opts.viewport,
+      userAgent: opts.userAgent
+    });
+  }
+  const session = createSession({
+    engine: resolvedEngine,
+    projectId: opts.projectId,
+    agentId: opts.agentId,
+    startUrl: opts.startUrl
+  });
+  handles.set(session.id, { browser, page, engine: resolvedEngine });
+  if (opts.startUrl) {
+    try {
+      await page.goto(opts.startUrl, { waitUntil: "domcontentloaded" });
+    } catch (err) {}
+  }
+  return { session, page };
+}
+function getSessionPage(sessionId) {
+  const handle = handles.get(sessionId);
+  if (!handle)
+    throw new SessionNotFoundError(sessionId);
+  return handle.page;
+}
+async function closeSession2(sessionId) {
+  const handle = handles.get(sessionId);
+  if (handle) {
+    try {
+      await handle.page.context().close();
+    } catch {}
+    try {
+      await closeBrowser(handle.browser);
+    } catch {}
+    handles.delete(sessionId);
+  }
+  return closeSession(sessionId);
+}
+function listSessions2(filter) {
+  return listSessions(filter);
+}
+
+// src/lib/actions.ts
+init_types();
+async function click(page, selector, opts) {
+  try {
+    await page.click(selector, {
+      button: opts?.button ?? "left",
+      clickCount: opts?.clickCount ?? 1,
+      delay: opts?.delay,
+      timeout: opts?.timeout ?? 1e4
+    });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) {
+      throw new ElementNotFoundError(selector);
+    }
+    throw new BrowserError(`Click failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "CLICK_FAILED");
+  }
+}
+async function type(page, selector, text, opts) {
+  try {
+    if (opts?.clear) {
+      await page.fill(selector, "", { timeout: opts?.timeout ?? 1e4 });
+    }
+    await page.type(selector, text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) {
+      throw new ElementNotFoundError(selector);
+    }
+    throw new BrowserError(`Type failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "TYPE_FAILED");
+  }
+}
+async function scroll(page, direction = "down", amount = 300) {
+  const x = direction === "left" ? -amount : direction === "right" ? amount : 0;
+  const y = direction === "up" ? -amount : direction === "down" ? amount : 0;
+  await page.evaluate(({ x: x2, y: y2 }) => window.scrollBy(x2, y2), { x, y });
+}
+async function navigate(page, url, timeout = 30000) {
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+  } catch (err) {
+    throw new NavigationError(url, err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/lib/extractor.ts
+async function getText(page, selector) {
+  if (selector) {
+    const el = await page.$(selector);
+    if (!el)
+      return "";
+    return await el.textContent() ?? "";
+  }
+  return page.evaluate(() => document.body.innerText ?? "");
+}
+async function getHTML(page, selector) {
+  if (selector) {
+    const el = await page.$(selector);
+    if (!el)
+      return "";
+    return await el.innerHTML() ?? "";
+  }
+  return page.content();
+}
+async function getLinks(page, baseUrl) {
+  return page.evaluate((base) => {
+    return Array.from(document.querySelectorAll("a[href]")).map((a) => {
+      const href = a.href;
+      if (!href)
+        return null;
+      if (href.startsWith("http"))
+        return href;
+      if (base && href.startsWith("/"))
+        return new URL(href, base).href;
+      return null;
+    }).filter((h) => h !== null);
+  }, baseUrl ?? page.url());
+}
+async function extractStructured(page, schema) {
+  const result = {};
+  for (const [field, selector] of Object.entries(schema)) {
+    const elements = await page.$$(selector);
+    if (elements.length === 0) {
+      result[field] = "";
+    } else if (elements.length === 1) {
+      result[field] = (await elements[0].textContent())?.trim() ?? "";
+    } else {
+      result[field] = await Promise.all(elements.map(async (el) => (await el.textContent())?.trim() ?? ""));
+    }
+  }
+  return result;
+}
+async function extractTable(page, selector) {
+  return page.evaluate((sel) => {
+    const table = document.querySelector(sel);
+    if (!table)
+      return [];
+    const rows = Array.from(table.querySelectorAll("tr"));
+    return rows.map((row) => Array.from(row.querySelectorAll("th, td")).map((cell) => cell.textContent?.trim() ?? ""));
+  }, selector);
+}
+async function extract(page, opts = {}) {
+  const result = {};
+  const format = opts.format ?? "text";
+  switch (format) {
+    case "text":
+      result.text = await getText(page, opts.selector);
+      break;
+    case "html":
+      result.html = await getHTML(page, opts.selector);
+      break;
+    case "links":
+      result.links = await getLinks(page);
+      break;
+    case "table":
+      result.table = opts.selector ? await extractTable(page, opts.selector) : [];
+      break;
+    case "structured":
+      if (opts.schema)
+        result.structured = await extractStructured(page, opts.schema);
+      break;
+  }
+  return result;
+}
+
+// src/lib/screenshot.ts
+init_types();
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+var DATA_DIR = process.env["BROWSER_DATA_DIR"] ?? join2(homedir2(), ".browser");
+function getScreenshotDir(projectId) {
+  const base = join2(DATA_DIR, "screenshots");
+  const date = new Date().toISOString().split("T")[0];
+  const dir = projectId ? join2(base, projectId, date) : join2(base, date);
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+async function takeScreenshot(page, opts) {
+  try {
+    const dir = getScreenshotDir(opts?.projectId);
+    const timestamp = Date.now();
+    const format = opts?.format ?? "png";
+    const screenshotPath = opts?.path ?? join2(dir, `${timestamp}.${format}`);
+    const screenshotOpts = {
+      path: screenshotPath,
+      fullPage: opts?.fullPage ?? false,
+      type: format === "webp" ? "jpeg" : format,
+      quality: format === "jpeg" || format === "webp" ? opts?.quality ?? 90 : undefined
+    };
+    let buffer;
+    if (opts?.selector) {
+      const el = await page.$(opts.selector);
+      if (!el)
+        throw new BrowserError(`Element not found: ${opts.selector}`, "ELEMENT_NOT_FOUND");
+      buffer = await el.screenshot({ ...screenshotOpts });
+    } else {
+      buffer = await page.screenshot(screenshotOpts);
+    }
+    const viewportSize = page.viewportSize() ?? { width: 1280, height: 720 };
+    return {
+      path: screenshotPath,
+      base64: buffer.toString("base64"),
+      width: viewportSize.width,
+      height: viewportSize.height,
+      size_bytes: buffer.length
+    };
+  } catch (err) {
+    if (err instanceof BrowserError)
+      throw err;
+    throw new BrowserError(`Screenshot failed: ${err instanceof Error ? err.message : String(err)}`, "SCREENSHOT_FAILED");
+  }
+}
+
+// src/db/network-log.ts
+init_schema();
+import { randomUUID as randomUUID2 } from "crypto";
+function logRequest(data) {
+  const db = getDatabase();
+  const id = randomUUID2();
+  db.prepare(`INSERT INTO network_log (id, session_id, method, url, status_code, request_headers,
+     response_headers, request_body, body_size, duration_ms, resource_type)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, data.session_id, data.method, data.url, data.status_code ?? null, data.request_headers ?? null, data.response_headers ?? null, data.request_body ?? null, data.body_size ?? null, data.duration_ms ?? null, data.resource_type ?? null);
+  return getNetworkRequest(id);
+}
+function getNetworkRequest(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM network_log WHERE id = ?").get(id) ?? null;
+}
+function getNetworkLog(sessionId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM network_log WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
+}
+function clearNetworkLog(sessionId) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM network_log WHERE session_id = ?").run(sessionId);
+}
+
+// src/lib/network.ts
+function enableNetworkLogging(page, sessionId) {
+  const requestStart = new Map;
+  const onRequest = (req) => {
+    requestStart.set(req.url(), Date.now());
+  };
+  const onResponse = (res) => {
+    const start = requestStart.get(res.url()) ?? Date.now();
+    const duration = Date.now() - start;
+    const req = res.request();
+    try {
+      logRequest({
+        session_id: sessionId,
+        method: req.method(),
+        url: res.url(),
+        status_code: res.status(),
+        request_headers: JSON.stringify(req.headers()),
+        response_headers: JSON.stringify(res.headers()),
+        body_size: res.headers()["content-length"] != null ? parseInt(res.headers()["content-length"]) : undefined,
+        duration_ms: duration,
+        resource_type: req.resourceType()
+      });
+    } catch {}
+  };
+  page.on("request", onRequest);
+  page.on("response", onResponse);
+  return () => {
+    page.off("request", onRequest);
+    page.off("response", onResponse);
+  };
+}
+function startHAR(page) {
+  const entries = [];
+  const requestStart = new Map;
+  const onRequest = (req) => {
+    requestStart.set(req.url() + req.method(), {
+      time: Date.now(),
+      method: req.method(),
+      headers: req.headers(),
+      postData: req.postData() ?? undefined
+    });
+  };
+  const onResponse = async (res) => {
+    const key = res.url() + res.request().method();
+    const start = requestStart.get(key);
+    if (!start)
+      return;
+    const duration = Date.now() - start.time;
+    const entry = {
+      startedDateTime: new Date(start.time).toISOString(),
+      time: duration,
+      request: {
+        method: start.method,
+        url: res.url(),
+        headers: Object.entries(start.headers).map(([name, value]) => ({ name, value })),
+        postData: start.postData ? { text: start.postData } : undefined
+      },
+      response: {
+        status: res.status(),
+        statusText: res.statusText(),
+        headers: Object.entries(res.headers()).map(([name, value]) => ({ name, value })),
+        content: {
+          size: parseInt(res.headers()["content-length"] ?? "0") || 0,
+          mimeType: res.headers()["content-type"] ?? "application/octet-stream"
+        }
+      },
+      timings: { send: 0, wait: duration, receive: 0 }
+    };
+    entries.push(entry);
+    requestStart.delete(key);
+  };
+  page.on("request", onRequest);
+  page.on("response", onResponse);
+  return {
+    entries,
+    stop: () => {
+      page.off("request", onRequest);
+      page.off("response", onResponse);
+      return {
+        log: {
+          version: "1.2",
+          creator: { name: "@hasna/browser", version: "0.0.1" },
+          entries
+        }
+      };
+    }
+  };
+}
+
+// src/engines/cdp.ts
+init_types();
+
+class CDPClient {
+  session;
+  networkEnabled = false;
+  performanceEnabled = false;
+  constructor(session) {
+    this.session = session;
+  }
+  static async fromPage(page) {
+    try {
+      const session = await page.context().newCDPSession(page);
+      return new CDPClient(session);
+    } catch (err) {
+      throw new BrowserError(`Failed to create CDP session: ${err instanceof Error ? err.message : String(err)}`, "CDP_SESSION_FAILED");
+    }
+  }
+  async send(method, params) {
+    try {
+      return await this.session.send(method, params);
+    } catch (err) {
+      throw new BrowserError(`CDP command '${method}' failed: ${err instanceof Error ? err.message : String(err)}`, "CDP_COMMAND_FAILED");
+    }
+  }
+  on(event, handler) {
+    this.session.on(event, handler);
+  }
+  off(event, handler) {
+    this.session.off(event, handler);
+  }
+  async enableNetwork() {
+    if (!this.networkEnabled) {
+      await this.send("Network.enable");
+      this.networkEnabled = true;
+    }
+  }
+  async enablePerformance() {
+    if (!this.performanceEnabled) {
+      await this.send("Performance.enable");
+      this.performanceEnabled = true;
+    }
+  }
+  async getPerformanceMetrics() {
+    await this.enablePerformance();
+    const result = await this.send("Performance.getMetrics");
+    const m = {};
+    for (const metric of result.metrics) {
+      m[metric.name] = metric.value;
+    }
+    return {
+      js_heap_size_used: m["JSHeapUsedSize"],
+      js_heap_size_total: m["JSHeapTotalSize"],
+      dom_interactive: m["DOMInteractive"],
+      dom_complete: m["DOMComplete"],
+      load_event: m["LoadEventEnd"]
+    };
+  }
+  async startJSCoverage() {
+    await this.send("Profiler.enable");
+    await this.send("Debugger.enable");
+    await this.send("Profiler.startPreciseCoverage", {
+      callCount: false,
+      detailed: true
+    });
+  }
+  async stopJSCoverage() {
+    const result = await this.send("Profiler.takePreciseCoverage");
+    await this.send("Profiler.stopPreciseCoverage");
+    return result.result.filter((r) => r.url && !r.url.startsWith("v8-snapshot://")).map((r) => ({
+      url: r.url,
+      text: "",
+      ranges: r.functions.flatMap((f) => f.ranges.filter((rng) => rng.count > 0).map((rng) => ({ start: rng.startOffset, end: rng.endOffset })))
+    }));
+  }
+  async getCoverage() {
+    await this.startJSCoverage();
+    const js = await this.stopJSCoverage();
+    const totalBytes = js.reduce((acc, e) => acc + e.ranges.reduce((sum, r) => sum + (r.end - r.start), 0), 0);
+    return { js, css: [], totalBytes, usedBytes: totalBytes, unusedPercent: 0 };
+  }
+  async captureHAREntries(page, handler) {
+    await this.enableNetwork();
+    const requestTimings = new Map;
+    const onRequest = (params) => {
+      requestTimings.set(params.requestId, params.timestamp);
+    };
+    const onResponse = (params) => {
+      const start = requestTimings.get(params.requestId);
+      const duration = start != null ? (params.timestamp - start) * 1000 : 0;
+      handler({
+        method: "GET",
+        url: params.response.url,
+        status: params.response.status,
+        duration
+      });
+    };
+    this.on("Network.requestWillBeSent", onRequest);
+    this.on("Network.responseReceived", onResponse);
+    return () => {
+      this.off("Network.requestWillBeSent", onRequest);
+      this.off("Network.responseReceived", onResponse);
+    };
+  }
+  async detach() {
+    try {
+      await this.session.detach();
+    } catch {}
+  }
+}
+
+// src/lib/performance.ts
+async function getPerformanceMetrics(page) {
+  const navTiming = await page.evaluate(() => {
+    const t = performance.timing;
+    const nav = performance.getEntriesByType("navigation")[0];
+    return {
+      ttfb: nav ? nav.responseStart - nav.requestStart : t.responseStart - t.requestStart,
+      domInteractive: nav ? nav.domInteractive : t.domInteractive - t.navigationStart,
+      domComplete: nav ? nav.domComplete : t.domComplete - t.navigationStart,
+      loadEvent: nav ? nav.loadEventEnd : t.loadEventEnd - t.navigationStart
+    };
+  });
+  const paintEntries = await page.evaluate(() => {
+    const entries = performance.getEntriesByType("paint");
+    const fcp = entries.find((e) => e.name === "first-contentful-paint");
+    return { fcp: fcp?.startTime };
+  });
+  let heapMetrics = {};
+  try {
+    const cdp = await CDPClient.fromPage(page);
+    const cdpMetrics = await cdp.getPerformanceMetrics();
+    heapMetrics = {
+      js_heap_size_used: cdpMetrics.js_heap_size_used,
+      js_heap_size_total: cdpMetrics.js_heap_size_total
+    };
+  } catch {}
+  return {
+    fcp: paintEntries.fcp,
+    ttfb: navTiming.ttfb,
+    dom_interactive: navTiming.domInteractive,
+    dom_complete: navTiming.domComplete,
+    load_event: navTiming.loadEvent,
+    ...heapMetrics
+  };
+}
+
+// src/db/console-log.ts
+init_schema();
+import { randomUUID as randomUUID3 } from "crypto";
+function logConsoleMessage(data) {
+  const db = getDatabase();
+  const id = randomUUID3();
+  db.prepare("INSERT INTO console_log (id, session_id, level, message, source, line_number) VALUES (?, ?, ?, ?, ?, ?)").run(id, data.session_id, data.level, data.message, data.source ?? null, data.line_number ?? null);
+  return getConsoleMessage(id);
+}
+function getConsoleMessage(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM console_log WHERE id = ?").get(id) ?? null;
+}
+function getConsoleLog(sessionId, level) {
+  const db = getDatabase();
+  if (level) {
+    return db.query("SELECT * FROM console_log WHERE session_id = ? AND level = ? ORDER BY timestamp ASC").all(sessionId, level);
+  }
+  return db.query("SELECT * FROM console_log WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
+}
+
+// src/lib/console.ts
+function enableConsoleCapture(page, sessionId) {
+  const onConsole = (msg) => {
+    const levelMap = {
+      log: "log",
+      warn: "warn",
+      error: "error",
+      debug: "debug",
+      info: "info",
+      warning: "warn"
+    };
+    const level = levelMap[msg.type()] ?? "log";
+    const location = msg.location();
+    try {
+      logConsoleMessage({
+        session_id: sessionId,
+        level,
+        message: msg.text(),
+        source: location.url || undefined,
+        line_number: location.lineNumber || undefined
+      });
+    } catch {}
+  };
+  page.on("console", onConsole);
+  return () => page.off("console", onConsole);
+}
+
+// src/lib/crawler.ts
+init_types();
+
+// src/db/crawl-results.ts
+init_schema();
+import { randomUUID as randomUUID4 } from "crypto";
+function deserialize(row) {
+  const pages = JSON.parse(row.pages);
+  return {
+    id: row.id,
+    project_id: row.project_id ?? undefined,
+    start_url: row.start_url,
+    depth: row.depth,
+    pages,
+    total_links: pages.reduce((acc, p) => acc + p.links.length, 0),
+    errors: JSON.parse(row.errors),
+    created_at: row.created_at
+  };
+}
+function createCrawlResult(data) {
+  const db = getDatabase();
+  const id = randomUUID4();
+  db.prepare("INSERT INTO crawl_results (id, project_id, start_url, depth, pages, links, errors) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, data.project_id ?? null, data.start_url, data.depth, JSON.stringify(data.pages), JSON.stringify(data.pages.flatMap((p) => p.links)), JSON.stringify(data.errors));
+  return getCrawlResult(id);
+}
+function getCrawlResult(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM crawl_results WHERE id = ?").get(id);
+  return row ? deserialize(row) : null;
+}
+
+// src/lib/crawler.ts
+async function crawl(startUrl, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 2;
+  const maxPages = opts.maxPages ?? 50;
+  const sameDomain = opts.sameDomain ?? true;
+  const engine = selectEngine("extract_links" /* EXTRACT_LINKS */, opts.engine);
+  const startDomain = new URL(startUrl).hostname;
+  const visited = new Set;
+  const pages = [];
+  const errors = [];
+  let browser;
+  if (engine === "lightpanda") {
+    browser = await connectLightpanda();
+  } else {
+    browser = await launchPlaywright({ headless: true });
+  }
+  const context = await browser.newContext({ viewport: { width: 1280, height: 720 } });
+  async function crawlPage(url, depth) {
+    if (depth > maxDepth || pages.length >= maxPages || visited.has(url))
+      return;
+    if (sameDomain && new URL(url).hostname !== startDomain)
+      return;
+    if (opts.filter && !opts.filter(url))
+      return;
+    visited.add(url);
+    const page = await context.newPage();
+    const crawled = { url, depth, links: [], error: undefined };
+    try {
+      const response = await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 });
+      crawled.title = await page.title();
+      crawled.status_code = response?.status();
+      crawled.links = await getLinks(page, url);
+      pages.push(crawled);
+      await page.close();
+      for (const link of crawled.links) {
+        if (pages.length >= maxPages)
+          break;
+        await crawlPage(link, depth + 1);
+      }
+    } catch (err) {
+      crawled.error = err instanceof Error ? err.message : String(err);
+      errors.push(`${url}: ${crawled.error}`);
+      pages.push(crawled);
+      await page.close().catch(() => {});
+    }
+  }
+  try {
+    await crawlPage(startUrl, 0);
+  } finally {
+    await browser.close().catch(() => {});
+  }
+  const result = createCrawlResult({
+    project_id: opts.projectId,
+    start_url: startUrl,
+    depth: maxDepth,
+    pages,
+    errors
+  });
+  return result;
+}
+
+// src/lib/recorder.ts
+init_recordings();
+init_types();
+var activeRecordings = new Map;
+async function replayRecording(recordingId, page) {
+  const recording = getRecording(recordingId);
+  const startTime = Date.now();
+  let executed = 0;
+  let failed = 0;
+  const errors = [];
+  for (const step of recording.steps) {
+    try {
+      switch (step.type) {
+        case "navigate":
+          if (step.url)
+            await navigate(page, step.url);
+          break;
+        case "click":
+          if (step.selector)
+            await click(page, step.selector);
+          break;
+        case "type":
+          if (step.selector && step.value)
+            await type(page, step.selector, step.value);
+          break;
+        case "scroll":
+          await scroll(page, "down");
+          break;
+        case "hover":
+          if (step.selector) {
+            const el = await page.$(step.selector);
+            if (el)
+              await el.hover();
+          }
+          break;
+        case "evaluate":
+          if (step.value)
+            await page.evaluate(step.value);
+          break;
+        case "wait":
+          if (step.selector) {
+            await page.waitForSelector(step.selector, { timeout: 1e4 }).catch(() => {});
+          }
+          break;
+      }
+      executed++;
+    } catch (err) {
+      failed++;
+      errors.push(`Step ${step.type} failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return {
+    recording_id: recordingId,
+    success: failed === 0,
+    steps_executed: executed,
+    steps_failed: failed,
+    errors,
+    duration_ms: Date.now() - startTime
+  };
+}
+
+// src/lib/agents.ts
+init_agents();
+function registerAgent2(name, opts = {}) {
+  return registerAgent(name, opts);
+}
+function heartbeat2(agentId) {
+  heartbeat(agentId);
+}
+
+// src/db/projects.ts
+init_schema();
+init_types();
+import { randomUUID as randomUUID7 } from "crypto";
+function createProject(data) {
+  const db = getDatabase();
+  const id = randomUUID7();
+  db.prepare("INSERT INTO projects (id, name, path, description) VALUES (?, ?, ?, ?)").run(id, data.name, data.path, data.description ?? null);
+  return getProject(id);
+}
+function ensureProject(name, path, description) {
+  const db = getDatabase();
+  const existing = db.query("SELECT * FROM projects WHERE name = ?").get(name);
+  if (existing)
+    return existing;
+  return createProject({ name, path, description });
+}
+function getProject(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM projects WHERE id = ?").get(id);
+  if (!row)
+    throw new ProjectNotFoundError(id);
+  return row;
+}
+function listProjects() {
+  const db = getDatabase();
+  return db.query("SELECT * FROM projects ORDER BY created_at DESC").all();
+}
+
+// src/server/index.ts
+init_recordings();
+var PORT = parseInt(process.env["BROWSER_SERVER_PORT"] ?? "7030");
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+var networkCleanup = new Map;
+var consoleCleanup = new Map;
+var harCaptures = new Map;
+function ok(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+function notFound(msg) {
+  return new Response(JSON.stringify({ error: msg }), {
+    status: 404,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+function badRequest(msg) {
+  return new Response(JSON.stringify({ error: msg }), {
+    status: 400,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+function serverError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return new Response(JSON.stringify({ error: msg }), {
+    status: 500,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+var server = Bun.serve({
+  port: PORT,
+  async fetch(req) {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    if (method === "OPTIONS") {
+      return new Response(null, { status: 204, headers: CORS_HEADERS });
+    }
+    try {
+      if (path === "/api/sessions" && method === "GET") {
+        const status = url.searchParams.get("status");
+        const projectId = url.searchParams.get("project_id") ?? undefined;
+        return ok({ sessions: listSessions2(status ? { status, projectId } : { projectId }) });
+      }
+      if (path === "/api/sessions" && method === "POST") {
+        const body = await req.json();
+        const { session } = await createSession2({
+          engine: body.engine ?? "auto",
+          projectId: body.project_id,
+          agentId: body.agent_id,
+          startUrl: body.start_url,
+          headless: body.headless ?? true
+        });
+        return ok({ session }, 201);
+      }
+      const sessionMatch = path.match(/^\/api\/sessions\/([^/]+)$/);
+      if (sessionMatch && method === "DELETE") {
+        const id = sessionMatch[1];
+        networkCleanup.get(id)?.();
+        consoleCleanup.get(id)?.();
+        networkCleanup.delete(id);
+        consoleCleanup.delete(id);
+        harCaptures.delete(id);
+        const session = await closeSession2(id);
+        return ok({ session });
+      }
+      if (path === "/api/navigate" && method === "POST") {
+        const body = await req.json();
+        if (!body.session_id || !body.url)
+          return badRequest("session_id and url required");
+        const page = getSessionPage(body.session_id);
+        await navigate(page, body.url);
+        return ok({ url: body.url, title: await page.title(), current_url: page.url() });
+      }
+      if (path === "/api/extract" && method === "POST") {
+        const body = await req.json();
+        if (!body.session_id)
+          return badRequest("session_id required");
+        const page = getSessionPage(body.session_id);
+        const result = await extract(page, { format: body.format, selector: body.selector });
+        return ok(result);
+      }
+      if (path === "/api/screenshot" && method === "POST") {
+        const body = await req.json();
+        if (!body.session_id)
+          return badRequest("session_id required");
+        const page = getSessionPage(body.session_id);
+        const result = await takeScreenshot(page, { selector: body.selector, fullPage: body.full_page });
+        return ok(result);
+      }
+      if (path.match(/^\/api\/screenshots\/([^/]+)$/) && method === "GET") {
+        const sessionId = path.split("/")[3];
+        const { listSnapshots: listSnapshots2 } = await Promise.resolve().then(() => (init_snapshots(), exports_snapshots));
+        return ok({ snapshots: listSnapshots2(sessionId) });
+      }
+      if (path.match(/^\/api\/network-log\/([^/]+)$/) && method === "GET") {
+        const sessionId = path.split("/")[3];
+        if (!networkCleanup.has(sessionId)) {
+          const page = getSessionPage(sessionId);
+          networkCleanup.set(sessionId, enableNetworkLogging(page, sessionId));
+        }
+        return ok({ requests: getNetworkLog(sessionId) });
+      }
+      if (path.match(/^\/api\/network-log\/([^/]+)$/) && method === "DELETE") {
+        const sessionId = path.split("/")[3];
+        clearNetworkLog(sessionId);
+        return ok({ cleared: true });
+      }
+      if (path.match(/^\/api\/console-log\/([^/]+)$/) && method === "GET") {
+        const sessionId = path.split("/")[3];
+        if (!consoleCleanup.has(sessionId)) {
+          const page = getSessionPage(sessionId);
+          consoleCleanup.set(sessionId, enableConsoleCapture(page, sessionId));
+        }
+        return ok({ messages: getConsoleLog(sessionId) });
+      }
+      if (path.match(/^\/api\/performance\/([^/]+)$/) && method === "GET") {
+        const sessionId = path.split("/")[3];
+        const page = getSessionPage(sessionId);
+        return ok({ metrics: await getPerformanceMetrics(page) });
+      }
+      if (path === "/api/har/start" && method === "POST") {
+        const body = await req.json();
+        const page = getSessionPage(body.session_id);
+        harCaptures.set(body.session_id, startHAR(page));
+        return ok({ started: true });
+      }
+      if (path === "/api/har/stop" && method === "POST") {
+        const body = await req.json();
+        const capture = harCaptures.get(body.session_id);
+        if (!capture)
+          return notFound("No active HAR capture");
+        const har = capture.stop();
+        harCaptures.delete(body.session_id);
+        return ok({ har });
+      }
+      if (path === "/api/recordings" && method === "GET") {
+        return ok({ recordings: listRecordings(url.searchParams.get("project_id") ?? undefined) });
+      }
+      if (path.match(/^\/api\/recordings\/([^/]+)\/replay$/) && method === "POST") {
+        const id = path.split("/")[3];
+        const body = await req.json();
+        const page = getSessionPage(body.session_id);
+        const result = await replayRecording(id, page);
+        return ok(result);
+      }
+      if (path.match(/^\/api\/recordings\/([^/]+)$/) && method === "DELETE") {
+        const id = path.split("/")[3];
+        const { deleteRecording: deleteRecording2 } = await Promise.resolve().then(() => (init_recordings(), exports_recordings));
+        deleteRecording2(id);
+        return ok({ deleted: id });
+      }
+      if (path === "/api/crawl" && method === "POST") {
+        const body = await req.json();
+        if (!body.url)
+          return badRequest("url required");
+        const result = await crawl(body.url, {
+          maxDepth: body.max_depth ?? 2,
+          maxPages: body.max_pages ?? 50,
+          engine: body.engine
+        });
+        return ok(result);
+      }
+      if (path === "/api/agents" && method === "GET") {
+        return ok({ agents: listAgents(url.searchParams.get("project_id") ?? undefined) });
+      }
+      if (path === "/api/agents" && method === "POST") {
+        const body = await req.json();
+        if (!body.name)
+          return badRequest("name required");
+        const agent = registerAgent2(body.name, { description: body.description, projectId: body.project_id, sessionId: body.session_id, workingDir: body.working_dir });
+        return ok({ agent }, 201);
+      }
+      if (path.match(/^\/api\/agents\/([^/]+)\/heartbeat$/) && method === "PUT") {
+        const id = path.split("/")[3];
+        heartbeat2(id);
+        return ok({ ok: true, agent_id: id, timestamp: new Date().toISOString() });
+      }
+      if (path.match(/^\/api\/agents\/([^/]+)$/) && method === "DELETE") {
+        const id = path.split("/")[3];
+        const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        deleteAgent2(id);
+        return ok({ deleted: id });
+      }
+      if (path === "/api/projects" && method === "GET") {
+        return ok({ projects: listProjects() });
+      }
+      if (path === "/api/projects" && method === "POST") {
+        const body = await req.json();
+        if (!body.name || !body.path)
+          return badRequest("name and path required");
+        const project = ensureProject(body.name, body.path, body.description);
+        return ok({ project }, 201);
+      }
+      const dashboardDist = join3(import.meta.dir, "../../dashboard/dist");
+      if (existsSync(dashboardDist)) {
+        const filePath = path === "/" ? join3(dashboardDist, "index.html") : join3(dashboardDist, path);
+        if (existsSync(filePath)) {
+          return new Response(Bun.file(filePath), { headers: CORS_HEADERS });
+        }
+        return new Response(Bun.file(join3(dashboardDist, "index.html")), { headers: CORS_HEADERS });
+      }
+      if (path === "/" || path === "") {
+        return new Response("@hasna/browser REST API running. Dashboard not built.", {
+          headers: { "Content-Type": "text/plain", ...CORS_HEADERS }
+        });
+      }
+      return notFound(`Route not found: ${method} ${path}`);
+    } catch (e) {
+      return serverError(e);
+    }
+  }
+});
+console.error(`@hasna/browser server running on http://localhost:${PORT}`);