@hasna/browser 0.0.9 → 0.1.1

package/dist/server/index.js

@@ -291,6 +291,71 @@ function runMigrations(db) {
         );
         CREATE INDEX IF NOT EXISTS idx_session_tags_tag ON session_tags(tag);
       `
+    },
+    {
+      version: 6,
+      sql: `
+        CREATE TABLE IF NOT EXISTS auth_flows (
+          id                 TEXT PRIMARY KEY,
+          name               TEXT NOT NULL UNIQUE,
+          domain             TEXT NOT NULL,
+          recording_id       TEXT REFERENCES recordings(id),
+          storage_state_path TEXT,
+          created_at         TEXT DEFAULT (datetime('now')),
+          last_used          TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_domain ON auth_flows(domain);
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_name ON auth_flows(name);
+      `
+    },
+    {
+      version: 7,
+      sql: `
+        CREATE TABLE IF NOT EXISTS workflows (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          description TEXT,
+          steps TEXT NOT NULL DEFAULT '[]',
+          start_url TEXT,
+          last_run TEXT,
+          last_heal TEXT,
+          heal_count INTEGER DEFAULT 0,
+          run_count INTEGER DEFAULT 0,
+          created_at TEXT DEFAULT (datetime('now')),
+          updated_at TEXT DEFAULT (datetime('now'))
+        );
+      `
+    },
+    {
+      version: 8,
+      sql: `
+        CREATE TABLE IF NOT EXISTS datasets (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          source_url TEXT,
+          source_type TEXT NOT NULL DEFAULT 'page',
+          data TEXT NOT NULL DEFAULT '[]',
+          schema TEXT,
+          row_count INTEGER DEFAULT 0,
+          last_refresh TEXT,
+          created_at TEXT DEFAULT (datetime('now')),
+          updated_at TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS api_endpoints (
+          id TEXT PRIMARY KEY,
+          session_id TEXT,
+          url TEXT NOT NULL,
+          method TEXT DEFAULT 'GET',
+          response_schema TEXT,
+          sample_response TEXT,
+          status_code INTEGER,
+          content_type TEXT,
+          discovered_at TEXT DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_api_endpoints_session ON api_endpoints(session_id);
+      `
     }
   ];
   for (const m of migrations) {
@@ -339,6 +404,188 @@ var init_console_log = __esm(() => {
   init_schema();
 });
 
+// src/engines/cdp.ts
+var exports_cdp = {};
+__export(exports_cdp, {
+  connectToExistingBrowser: () => connectToExistingBrowser,
+  CDPClient: () => CDPClient
+});
+async function connectToExistingBrowser(cdpUrl) {
+  const { chromium: chromium3 } = await import("playwright");
+  try {
+    return await chromium3.connectOverCDP(cdpUrl);
+  } catch (err) {
+    throw new BrowserError(`Failed to connect to browser at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}. Start Chrome with: google-chrome --remote-debugging-port=9222`, "CDP_CONNECT_FAILED", true);
+  }
+}
+
+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 {}
+  }
+}
+var init_cdp = __esm(() => {
+  init_types();
+});
+
+// src/lib/storage-state.ts
+var exports_storage_state = {};
+__export(exports_storage_state, {
+  saveStateFromPage: () => saveStateFromPage,
+  saveState: () => saveState,
+  loadStatePath: () => loadStatePath,
+  listStates: () => listStates,
+  deleteState: () => deleteState
+});
+import { mkdirSync as mkdirSync3, existsSync, readdirSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function ensureDir() {
+  mkdirSync3(STATES_DIR, { recursive: true });
+}
+function statePath(name) {
+  return join3(STATES_DIR, `${name}.json`);
+}
+async function saveState(context, name) {
+  ensureDir();
+  const path = statePath(name);
+  const state = await context.storageState({ path });
+  return path;
+}
+async function saveStateFromPage(page, name) {
+  return saveState(page.context(), name);
+}
+function loadStatePath(name) {
+  const path = statePath(name);
+  return existsSync(path) ? path : null;
+}
+function listStates() {
+  ensureDir();
+  return readdirSync(STATES_DIR).filter((f) => f.endsWith(".json")).map((f) => {
+    const path = join3(STATES_DIR, f);
+    const stat = Bun.file(path);
+    return {
+      name: f.replace(".json", ""),
+      path,
+      modified: new Date(stat.lastModified).toISOString()
+    };
+  }).sort((a, b) => b.modified.localeCompare(a.modified));
+}
+function deleteState(name) {
+  const path = statePath(name);
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+var STATES_DIR;
+var init_storage_state = __esm(() => {
+  STATES_DIR = join3(process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser"), "states");
+});
+
 // node_modules/sharp/lib/is.js
 var require_is = __commonJS((exports, module) => {
   /*!
@@ -6933,8 +7180,8 @@ var init_snapshots = __esm(() => {
 });
 
 // src/server/index.ts
-import { join as join6 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { join as join7 } from "path";
+import { existsSync as existsSync4 } from "fs";
 
 // src/lib/session.ts
 init_types();
@@ -7862,6 +8109,37 @@ function createBunProxy(view) {
   return view;
 }
 async function createSession2(opts = {}) {
+  if (opts.cdpUrl) {
+    const { connectToExistingBrowser: connectToExistingBrowser2 } = await Promise.resolve().then(() => (init_cdp(), exports_cdp));
+    const cdpBrowser = await connectToExistingBrowser2(opts.cdpUrl);
+    const contexts = cdpBrowser.contexts();
+    const context = contexts.length > 0 ? contexts[0] : await cdpBrowser.newContext();
+    const pages = context.pages();
+    const page2 = pages.length > 0 ? pages[0] : await context.newPage();
+    const session2 = createSession({
+      engine: "cdp",
+      projectId: opts.projectId,
+      agentId: opts.agentId,
+      startUrl: page2.url(),
+      name: opts.name ?? "attached"
+    });
+    const cleanups2 = [];
+    if (opts.captureNetwork !== false) {
+      try {
+        cleanups2.push(enableNetworkLogging(page2, session2.id));
+      } catch {}
+    }
+    if (opts.captureConsole !== false) {
+      try {
+        cleanups2.push(enableConsoleCapture(page2, session2.id));
+      } catch {}
+    }
+    try {
+      cleanups2.push(setupDialogHandler(page2, session2.id));
+    } catch {}
+    handles.set(session2.id, { browser: cdpBrowser, bunView: null, page: page2, engine: "cdp", cleanups: cleanups2, tokenBudget: { total: 0, used: 0 }, lastActivity: Date.now(), autoGallery: opts.autoGallery ?? false });
+    return { session: session2, page: page2 };
+  }
   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 = null;
@@ -7887,7 +8165,22 @@ async function createSession2(opts = {}) {
     page = await context.newPage();
   } else {
     browser = await pool.acquire(opts.headless ?? true);
-    page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    if (opts.storageState) {
+      const { loadStatePath: loadStatePath2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const statePath2 = loadStatePath2(opts.storageState);
+      if (statePath2) {
+        const context = await browser.newContext({
+          viewport: opts.viewport ?? { width: 1280, height: 720 },
+          userAgent: opts.userAgent,
+          storageState: statePath2
+        });
+        page = await context.newPage();
+      } else {
+        page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+      }
+    } else {
+      page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    }
   }
   const sessionName = opts.name ?? (opts.startUrl ? (() => {
     try {
@@ -8003,6 +8296,66 @@ init_types();
 var lastSnapshots = new Map;
 var sessionRefMaps = new Map;
 
+// src/lib/self-heal.ts
+async function healSelector(page, selector, sessionId) {
+  const attempts = [];
+  attempts.push(`selector: ${selector}`);
+  try {
+    const loc = page.locator(selector).first();
+    if (await loc.count() > 0) {
+      return { found: true, locator: loc, method: "original", healed: false, attempts };
+    }
+  } catch {}
+  if (!selector.startsWith("#") && !selector.startsWith(".") && !selector.startsWith("[") && !selector.includes(">") && !selector.includes(" ")) {
+    attempts.push(`text: "${selector}"`);
+    try {
+      const loc = page.getByText(selector, { exact: false }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "text", healed: true, attempts };
+      }
+    } catch {}
+  }
+  const roleMap = {
+    button: ["button", "submit", "reset"],
+    link: ["a"],
+    input: ["input", "textarea"],
+    heading: ["h1", "h2", "h3", "h4", "h5", "h6"]
+  };
+  const nameHint = selector.replace(/^[#.]/, "").replace(/[-_]/g, " ").toLowerCase();
+  for (const [role, tags] of Object.entries(roleMap)) {
+    attempts.push(`role: ${role} name~="${nameHint}"`);
+    try {
+      const loc = page.getByRole(role, { name: new RegExp(nameHint.split(" ")[0], "i") }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "role", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith("#")) {
+    const idPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[id*="${idPart}"]`;
+    attempts.push(`partial_id: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_id", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith(".")) {
+    const classPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[class*="${classPart}"]`;
+    attempts.push(`partial_class: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_class", healed: true, attempts };
+      }
+    } catch {}
+  }
+  return { found: false, locator: null, method: "none", healed: false, attempts };
+}
+
 // src/lib/actions.ts
 async function click(page, selector, opts) {
   try {
@@ -8012,11 +8365,22 @@ async function click(page, selector, opts) {
       delay: opts?.delay,
       timeout: opts?.timeout ?? 1e4
     });
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        await result.locator.click({
+          button: opts?.button ?? "left",
+          timeout: opts?.timeout ?? 1e4
+        });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Click failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "CLICK_FAILED");
+    throw new BrowserError(`Click failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "CLICK_FAILED");
   }
 }
 async function type(page, selector, text, opts) {
@@ -8025,11 +8389,21 @@ async function type(page, selector, text, opts) {
       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")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        if (opts?.clear)
+          await result.locator.fill("", { timeout: opts?.timeout ?? 1e4 });
+        await result.locator.pressSequentially(text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Type failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "TYPE_FAILED");
+    throw new BrowserError(`Type failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "TYPE_FAILED");
   }
 }
 async function scroll(page, direction = "down", amount = 300) {
@@ -8129,9 +8503,9 @@ async function extract(page, opts = {}) {
 // src/lib/screenshot.ts
 init_types();
 var import_sharp = __toESM(require_lib(), 1);
-import { join as join3 } from "path";
-import { mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir4 } from "os";
 
 // src/db/gallery.ts
 init_schema();
@@ -8261,13 +8635,13 @@ function getGalleryStats(projectId) {
 
 // src/lib/screenshot.ts
 function getDataDir2() {
-  return process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join4(homedir4(), ".browser");
 }
 function getScreenshotDir(projectId) {
-  const base = join3(getDataDir2(), "screenshots");
+  const base = join4(getDataDir2(), "screenshots");
   const date = new Date().toISOString().split("T")[0];
-  const dir = projectId ? join3(base, projectId, date) : join3(base, date);
-  mkdirSync3(dir, { recursive: true });
+  const dir = projectId ? join4(base, projectId, date) : join4(base, date);
+  mkdirSync4(dir, { recursive: true });
   return dir;
 }
 async function compressBuffer(raw, format, quality, maxWidth) {
@@ -8282,7 +8656,7 @@ async function compressBuffer(raw, format, quality, maxWidth) {
   }
 }
 async function generateThumbnail(raw, dir, stem) {
-  const thumbPath = join3(dir, `${stem}.thumb.webp`);
+  const thumbPath = join4(dir, `${stem}.thumb.webp`);
   const thumbBuffer = await import_sharp.default(raw).resize({ width: 200, withoutEnlargement: true }).webp({ quality: 70, effort: 3 }).toBuffer();
   await Bun.write(thumbPath, thumbBuffer);
   return { path: thumbPath, base64: thumbBuffer.toString("base64") };
@@ -8339,7 +8713,7 @@ async function takeScreenshot(page, opts) {
     const compressedSizeBytes = finalBuffer.length;
     const compressionRatio = originalSizeBytes > 0 ? compressedSizeBytes / originalSizeBytes : 1;
     const ext = format;
-    const screenshotPath = opts?.path ?? join3(dir, `${stem}.${ext}`);
+    const screenshotPath = opts?.path ?? join4(dir, `${stem}.${ext}`);
     await Bun.write(screenshotPath, finalBuffer);
     let thumbnailPath;
     let thumbnailBase64;
@@ -8398,118 +8772,8 @@ async function takeScreenshot(page, opts) {
   }
 }
 
-// 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
+init_cdp();
 async function getPerformanceMetrics(page) {
   const navTiming = await page.evaluate(() => {
     const t = performance.timing;
@@ -8742,16 +9006,16 @@ init_console_log();
 init_recordings();
 
 // src/lib/downloads.ts
-import { join as join4, basename, extname } from "path";
-import { mkdirSync as mkdirSync4, existsSync, readdirSync, statSync, unlinkSync, copyFileSync, writeFileSync, readFileSync } from "fs";
-import { homedir as homedir4 } from "os";
+import { join as join5, basename, extname } from "path";
+import { mkdirSync as mkdirSync5, existsSync as existsSync2, readdirSync as readdirSync2, statSync, unlinkSync as unlinkSync2, copyFileSync, writeFileSync, readFileSync } from "fs";
+import { homedir as homedir5 } from "os";
 function getDataDir3() {
-  return process.env["BROWSER_DATA_DIR"] ?? join4(homedir4(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join5(homedir5(), ".browser");
 }
 function getDownloadsDir(sessionId) {
-  const base = join4(getDataDir3(), "downloads");
-  const dir = sessionId ? join4(base, sessionId) : base;
-  mkdirSync4(dir, { recursive: true });
+  const base = join5(getDataDir3(), "downloads");
+  const dir = sessionId ? join5(base, sessionId) : base;
+  mkdirSync5(dir, { recursive: true });
   return dir;
 }
 function metaPath(filePath) {
@@ -8761,20 +9025,20 @@ function listDownloads(sessionId) {
   const dir = getDownloadsDir(sessionId);
   const results = [];
   function scanDir(d) {
-    if (!existsSync(d))
+    if (!existsSync2(d))
       return;
-    const entries = readdirSync(d);
+    const entries = readdirSync2(d);
     for (const entry of entries) {
       if (entry.endsWith(".meta.json"))
         continue;
-      const full = join4(d, entry);
+      const full = join5(d, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         scanDir(full);
         continue;
       }
       const mpath = metaPath(full);
-      if (!existsSync(mpath))
+      if (!existsSync2(mpath))
         continue;
       try {
         const meta = JSON.parse(readFileSync(mpath, "utf8"));
@@ -8804,9 +9068,9 @@ function deleteDownload(id, sessionId) {
   if (!file)
     return false;
   try {
-    unlinkSync(file.path);
-    if (existsSync(file.meta_path))
-      unlinkSync(file.meta_path);
+    unlinkSync2(file.path);
+    if (existsSync2(file.meta_path))
+      unlinkSync2(file.meta_path);
     return true;
   } catch {
     return false;
@@ -8828,9 +9092,9 @@ function cleanStaleDownloads(olderThanDays = 7) {
 
 // src/lib/gallery-diff.ts
 var import_sharp2 = __toESM(require_lib(), 1);
-import { join as join5 } from "path";
-import { mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir6 } from "os";
 async function diffImages(path1, path2) {
   const img1 = import_sharp2.default(path1);
   const img2 = import_sharp2.default(path2);
@@ -8861,10 +9125,10 @@ async function diffImages(path1, path2) {
       diffBuffer[i + 2] = Math.round(raw1[i + 2] * 0.4);
     }
   }
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join5(homedir5(), ".browser");
-  const diffDir = join5(dataDir, "diffs");
-  mkdirSync5(diffDir, { recursive: true });
-  const diffPath = join5(diffDir, `diff-${Date.now()}.webp`);
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join6(homedir6(), ".browser");
+  const diffDir = join6(dataDir, "diffs");
+  mkdirSync6(diffDir, { recursive: true });
+  const diffPath = join6(diffDir, `diff-${Date.now()}.webp`);
   const diffImageBuffer = await import_sharp2.default(diffBuffer, { raw: { width: w, height: h, channels } }).webp({ quality: 85 }).toBuffer();
   await Bun.write(diffPath, diffImageBuffer);
   return {
@@ -9108,14 +9372,14 @@ var server = Bun.serve({
       if (path.match(/^\/api\/gallery\/([^/]+)\/thumbnail$/) && method === "GET") {
         const id = path.split("/")[3];
         const entry = getEntry(id);
-        if (!entry?.thumbnail_path || !existsSync3(entry.thumbnail_path))
+        if (!entry?.thumbnail_path || !existsSync4(entry.thumbnail_path))
           return notFound("Thumbnail not found");
         return new Response(Bun.file(entry.thumbnail_path), { headers: { ...CORS_HEADERS } });
       }
       if (path.match(/^\/api\/gallery\/([^/]+)\/image$/) && method === "GET") {
         const id = path.split("/")[3];
         const entry = getEntry(id);
-        if (!entry?.path || !existsSync3(entry.path))
+        if (!entry?.path || !existsSync4(entry.path))
           return notFound("Image not found");
         return new Response(Bun.file(entry.path), { headers: { ...CORS_HEADERS } });
       }
@@ -9143,7 +9407,7 @@ var server = Bun.serve({
       if (path.match(/^\/api\/downloads\/([^/]+)\/raw$/) && method === "GET") {
         const id = path.split("/")[3];
         const file = getDownload(id);
-        if (!file || !existsSync3(file.path))
+        if (!file || !existsSync4(file.path))
           return notFound("Download not found");
         return new Response(Bun.file(file.path), { headers: { ...CORS_HEADERS } });
       }
@@ -9151,13 +9415,13 @@ var server = Bun.serve({
         const id = path.split("/")[3];
         return ok({ deleted: deleteDownload(id) });
       }
-      const dashboardDist = join6(import.meta.dir, "../../dashboard/dist");
-      if (existsSync3(dashboardDist)) {
-        const filePath = path === "/" ? join6(dashboardDist, "index.html") : join6(dashboardDist, path);
-        if (existsSync3(filePath)) {
+      const dashboardDist = join7(import.meta.dir, "../../dashboard/dist");
+      if (existsSync4(dashboardDist)) {
+        const filePath = path === "/" ? join7(dashboardDist, "index.html") : join7(dashboardDist, path);
+        if (existsSync4(filePath)) {
           return new Response(Bun.file(filePath), { headers: CORS_HEADERS });
         }
-        return new Response(Bun.file(join6(dashboardDist, "index.html")), { headers: CORS_HEADERS });
+        return new Response(Bun.file(join7(dashboardDist, "index.html")), { headers: CORS_HEADERS });
       }
       if (path === "/" || path === "") {
         return new Response("@hasna/browser REST API running. Dashboard not built.", {