@hasna/browser 0.1.0 → 0.2.0

package/dist/cli/index.js

@@ -2358,6 +2358,54 @@ function runMigrations(db) {
         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) {
@@ -3322,14 +3370,14 @@ function enableConsoleCapture(page, sessionId) {
       warning: "warn"
     };
     const level = levelMap[msg.type()] ?? "log";
-    const location = msg.location();
+    const location2 = msg.location();
     try {
       logConsoleMessage({
         session_id: sessionId,
         level,
         message: msg.text(),
-        source: location.url || undefined,
-        line_number: location.lineNumber || undefined
+        source: location2.url || undefined,
+        line_number: location2.lineNumber || undefined
       });
     } catch {}
   };
@@ -12116,6 +12164,743 @@ var init_recorder = __esm(() => {
   activeRecordings = new Map;
 });
 
+// src/lib/env-detector.ts
+var exports_env_detector = {};
+__export(exports_env_detector, {
+  detectEnvironment: () => detectEnvironment
+});
+async function detectEnvironment(page) {
+  const url = page.url();
+  const signals = [];
+  let score = { local: 0, dev: 0, staging: 0, prod: 0 };
+  try {
+    const u = new URL(url);
+    if (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "0.0.0.0" || u.hostname.endsWith(".local")) {
+      score.local += 5;
+      signals.push(`URL hostname: ${u.hostname} \u2192 local`);
+    } else if (u.hostname.match(/^(dev|development)\./i) || u.port !== "") {
+      score.dev += 4;
+      signals.push(`URL pattern: ${u.hostname}:${u.port} \u2192 dev`);
+    } else if (u.hostname.match(/^(staging|stg|stage|preprod|uat)\./i)) {
+      score.staging += 4;
+      signals.push(`URL pattern: ${u.hostname} \u2192 staging`);
+    } else {
+      score.prod += 2;
+      signals.push(`URL looks production: ${u.hostname}`);
+    }
+    if (u.port && !["80", "443", ""].includes(u.port)) {
+      score.dev += 2;
+      signals.push(`Non-standard port: ${u.port}`);
+    }
+    if (u.protocol === "https:") {
+      score.prod += 1;
+      signals.push("HTTPS \u2192 likely prod");
+    } else {
+      score.dev += 2;
+      signals.push("HTTP \u2192 likely dev/local");
+    }
+  } catch {}
+  try {
+    const pageSignals = await page.evaluate(() => {
+      const s = [];
+      const w = window;
+      const envVars = ["__ENV__", "__NEXT_DATA__", "__NUXT__", "process"];
+      for (const v of envVars) {
+        if (w[v]) {
+          const env2 = w[v]?.env?.NODE_ENV ?? w[v]?.runtimeConfig?.public?.env ?? w[v]?.props?.pageProps?.env;
+          if (env2)
+            s.push(`window.${v}: ${env2}`);
+        }
+      }
+      if (w.__REACT_DEVTOOLS_GLOBAL_HOOK__?.renderers?.size > 0) {
+        const fiber = document.querySelector("[data-reactroot]") || document.getElementById("__next") || document.getElementById("root");
+        if (fiber)
+          s.push("React app detected");
+      }
+      const envMeta = document.querySelector('meta[name="environment"], meta[name="env"], meta[name="deploy-env"]');
+      if (envMeta)
+        s.push(`meta[environment]: ${envMeta.getAttribute("content")}`);
+      const scripts = document.querySelectorAll("script[src]");
+      let minified = 0, unminified = 0;
+      scripts.forEach((s2) => {
+        const src = s2.getAttribute("src") ?? "";
+        if (src.includes(".min.") || src.match(/\.[a-f0-9]{8,}\./))
+          minified++;
+        else if (src.endsWith(".js") && !src.includes("chunk"))
+          unminified++;
+      });
+      if (unminified > minified && unminified > 2)
+        s.push(`Unminified scripts (${unminified}/${minified + unminified}) \u2192 likely dev`);
+      else if (minified > 0)
+        s.push(`Minified/hashed scripts (${minified}/${minified + unminified}) \u2192 likely prod`);
+      if (document.querySelector("[data-testid]"))
+        s.push("data-testid attributes present \u2192 dev/staging");
+      if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+        s.push("Service worker active \u2192 likely prod");
+      }
+      if (w.Sentry)
+        s.push("Sentry SDK loaded \u2192 prod monitoring");
+      if (w.__DATADOG_SYNTHETICS_INLINED_SCRIPT)
+        s.push("Datadog loaded \u2192 prod monitoring");
+      if (w.LogRocket)
+        s.push("LogRocket loaded \u2192 prod monitoring");
+      if (w._lr_loaded)
+        s.push("LogRocket loaded \u2192 prod monitoring");
+      if (w.gtag || w.ga)
+        s.push("Google Analytics loaded \u2192 likely prod");
+      if (w.posthog || w._ph)
+        s.push("PostHog loaded \u2192 prod analytics");
+      if (w.mixpanel)
+        s.push("Mixpanel loaded \u2192 prod analytics");
+      const robots = document.querySelector('meta[name="robots"]');
+      if (robots) {
+        const content = robots.getAttribute("content") ?? "";
+        if (content.includes("noindex"))
+          s.push(`robots: noindex \u2192 staging/dev`);
+      }
+      return s;
+    });
+    for (const signal of pageSignals) {
+      signals.push(signal);
+      if (signal.includes("development") || signal.includes("\u2192 dev") || signal.includes("\u2192 likely dev"))
+        score.dev += 2;
+      if (signal.includes("production") || signal.includes("\u2192 prod") || signal.includes("\u2192 likely prod"))
+        score.prod += 2;
+      if (signal.includes("staging") || signal.includes("\u2192 staging"))
+        score.staging += 2;
+      if (signal.includes("monitoring") || signal.includes("analytics"))
+        score.prod += 1;
+      if (signal.includes("noindex")) {
+        score.staging += 2;
+        score.dev += 1;
+      }
+    }
+  } catch {}
+  const entries = Object.entries(score);
+  entries.sort((a, b) => b[1] - a[1]);
+  const [env, topScore] = entries[0];
+  const [, secondScore] = entries[1];
+  const confidence = topScore >= 5 ? "high" : topScore > secondScore + 1 ? "medium" : "low";
+  return { env, confidence, signals };
+}
+
+// src/lib/deep-performance.ts
+var exports_deep_performance = {};
+__export(exports_deep_performance, {
+  getDeepPerformance: () => getDeepPerformance
+});
+function categorizeThirdParty(domain) {
+  for (const [pattern, category] of Object.entries(THIRD_PARTY_CATEGORIES)) {
+    if (domain.includes(pattern))
+      return category;
+  }
+  return "other";
+}
+async function getDeepPerformance(page) {
+  return page.evaluate(() => {
+    const perf = performance;
+    const entries = perf.getEntriesByType("resource");
+    const navEntry = perf.getEntriesByType("navigation")[0];
+    const paintEntries = perf.getEntriesByType("paint");
+    const fcp = paintEntries.find((e) => e.name === "first-contentful-paint")?.startTime;
+    const ttfb = navEntry?.responseStart;
+    const web_vitals = { fcp, ttfb };
+    try {
+      const lcpEntries = perf.getEntriesByType("largest-contentful-paint");
+      if (lcpEntries.length > 0)
+        web_vitals.lcp = lcpEntries[lcpEntries.length - 1].startTime;
+    } catch {}
+    const byType = {};
+    let totalBytes = 0;
+    const resourceList = [];
+    const pageDomain = location.hostname;
+    const thirdPartyMap = new Map;
+    for (const entry of entries) {
+      const size = entry.transferSize || entry.encodedBodySize || 0;
+      totalBytes += size;
+      let type2 = entry.initiatorType || "other";
+      if (type2 === "xmlhttprequest" || type2 === "fetch")
+        type2 = "xhr";
+      if (type2 === "link" && entry.name.match(/\.css/))
+        type2 = "css";
+      if (type2 === "img" || entry.name.match(/\.(png|jpg|jpeg|gif|svg|webp|avif|ico)/i))
+        type2 = "image";
+      if (type2 === "script" || entry.name.match(/\.js/))
+        type2 = "script";
+      if (entry.name.match(/\.(woff2?|ttf|otf|eot)/i))
+        type2 = "font";
+      if (!byType[type2])
+        byType[type2] = { count: 0, size_bytes: 0 };
+      byType[type2].count++;
+      byType[type2].size_bytes += size;
+      resourceList.push({ url: entry.name, size_bytes: size, type: type2 });
+      try {
+        const domain = new URL(entry.name).hostname;
+        if (domain !== pageDomain && !domain.endsWith(`.${pageDomain}`)) {
+          if (!thirdPartyMap.has(domain))
+            thirdPartyMap.set(domain, { scripts: 0, total_bytes: 0 });
+          const tp = thirdPartyMap.get(domain);
+          tp.scripts++;
+          tp.total_bytes += size;
+        }
+      } catch {}
+    }
+    resourceList.sort((a, b) => b.size_bytes - a.size_bytes);
+    const largest = resourceList.slice(0, 10).map((r) => ({
+      url: r.url.length > 120 ? r.url.slice(0, 117) + "..." : r.url,
+      size_bytes: r.size_bytes,
+      type: r.type
+    }));
+    const third_party = Array.from(thirdPartyMap.entries()).map(([domain, data]) => ({ domain, ...data, category: "" })).sort((a, b) => b.total_bytes - a.total_bytes).slice(0, 15);
+    const allNodes = document.querySelectorAll("*");
+    let maxDepth = 0;
+    let textNodes = 0;
+    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ALL);
+    let node = walker.currentNode;
+    while (node) {
+      if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim())
+        textNodes++;
+      let depth = 0;
+      let parent = node.parentNode;
+      while (parent) {
+        depth++;
+        parent = parent.parentNode;
+      }
+      if (depth > maxDepth)
+        maxDepth = depth;
+      node = walker.nextNode();
+    }
+    const mem = performance.memory;
+    const memory = {
+      js_heap_used_mb: mem ? Math.round(mem.usedJSHeapSize / 1024 / 1024 * 100) / 100 : 0,
+      js_heap_total_mb: mem ? Math.round(mem.totalJSHeapSize / 1024 / 1024 * 100) / 100 : 0,
+      js_heap_limit_mb: mem ? Math.round(mem.jsHeapSizeLimit / 1024 / 1024 * 100) / 100 : 0
+    };
+    return {
+      web_vitals,
+      resources: { total_transfer_bytes: totalBytes, total_resources: entries.length, by_type: byType, largest },
+      third_party,
+      dom: { node_count: document.all.length, max_depth: maxDepth, element_count: allNodes.length, text_node_count: textNodes },
+      main_thread: { long_tasks: 0, total_blocking_ms: 0 },
+      memory
+    };
+  }).then((result) => {
+    for (const tp of result.third_party) {
+      tp.category = categorizeThirdParty(tp.domain);
+    }
+    return result;
+  });
+}
+var THIRD_PARTY_CATEGORIES;
+var init_deep_performance = __esm(() => {
+  THIRD_PARTY_CATEGORIES = {
+    "google-analytics.com": "analytics",
+    "googletagmanager.com": "analytics",
+    gtag: "analytics",
+    "facebook.net": "social",
+    "connect.facebook": "social",
+    "stripe.com": "payment",
+    "js.stripe.com": "payment",
+    "sentry.io": "monitoring",
+    "sentry-cdn": "monitoring",
+    "posthog.com": "analytics",
+    "ph.": "analytics",
+    "intercom.io": "chat",
+    "crisp.chat": "chat",
+    "hotjar.com": "analytics",
+    "clarity.ms": "analytics",
+    "cdn.jsdelivr.net": "cdn",
+    "cdnjs.cloudflare.com": "cdn",
+    "unpkg.com": "cdn",
+    "fonts.googleapis.com": "fonts",
+    "fonts.gstatic.com": "fonts"
+  };
+});
+
+// src/lib/api-detector.ts
+var exports_api_detector = {};
+__export(exports_api_detector, {
+  listDiscoveredAPIs: () => listDiscoveredAPIs,
+  detectAPIs: () => detectAPIs
+});
+import { randomUUID as randomUUID9 } from "crypto";
+function detectAPIs(sessionId) {
+  const db = getDatabase();
+  const requests = db.query(`SELECT method, url, status_code, response_headers, body_size
+     FROM network_log
+     WHERE session_id = ?
+     AND (response_headers LIKE '%application/json%' OR response_headers LIKE '%text/json%')
+     AND status_code >= 200 AND status_code < 400
+     ORDER BY timestamp DESC`).all(sessionId);
+  const seen = new Map;
+  for (const req of requests) {
+    try {
+      const urlObj = new URL(req.url);
+      if (urlObj.pathname.match(/\.(js|css|png|jpg|svg|woff|ico)$/))
+        continue;
+      if (urlObj.hostname.includes("googleapis.com/identitytoolkit"))
+        continue;
+      if (urlObj.hostname.includes("posthog"))
+        continue;
+      if (urlObj.hostname.includes("sentry"))
+        continue;
+      const key = `${req.method} ${urlObj.origin}${urlObj.pathname}`;
+      if (!seen.has(key)) {
+        seen.set(key, {
+          url: `${urlObj.origin}${urlObj.pathname}`,
+          method: req.method,
+          status_code: req.status_code,
+          content_type: "application/json",
+          response_schema: {},
+          sample_size: req.body_size ?? 0
+        });
+      }
+    } catch {}
+  }
+  const apis = Array.from(seen.values());
+  for (const api of apis) {
+    const id = randomUUID9();
+    db.prepare("INSERT OR IGNORE INTO api_endpoints (id, session_id, url, method, status_code, content_type) VALUES (?, ?, ?, ?, ?, ?)").run(id, sessionId, api.url, api.method, api.status_code, api.content_type);
+  }
+  return apis;
+}
+function listDiscoveredAPIs(sessionId) {
+  const db = getDatabase();
+  if (sessionId) {
+    return db.query("SELECT * FROM api_endpoints WHERE session_id = ? ORDER BY discovered_at DESC").all(sessionId);
+  }
+  return db.query("SELECT * FROM api_endpoints ORDER BY discovered_at DESC LIMIT 100").all();
+}
+var init_api_detector = __esm(() => {
+  init_schema();
+});
+
+// src/lib/structured-extract.ts
+var exports_structured_extract = {};
+__export(exports_structured_extract, {
+  extractStructuredData: () => extractStructuredData
+});
+async function extractStructuredData(page) {
+  return page.evaluate(() => {
+    const result = { tables: [], lists: [], jsonLd: [], openGraph: {}, metaTags: {}, repeatedElements: [] };
+    document.querySelectorAll("table").forEach((table, idx) => {
+      const headers = [];
+      table.querySelectorAll("thead th, thead td, tr:first-child th").forEach((th) => {
+        headers.push(th.textContent?.trim() ?? "");
+      });
+      const rows = [];
+      table.querySelectorAll("tbody tr, tr:not(:first-child)").forEach((tr) => {
+        const row = [];
+        tr.querySelectorAll("td, th").forEach((td) => {
+          row.push(td.textContent?.trim() ?? "");
+        });
+        if (row.length > 0 && row.some((c) => c !== ""))
+          rows.push(row);
+      });
+      if (rows.length > 0) {
+        result.tables.push({ headers, rows, selector: `table:nth-of-type(${idx + 1})` });
+      }
+    });
+    document.querySelectorAll("ul, ol").forEach((list, idx) => {
+      const items = [];
+      list.querySelectorAll(":scope > li").forEach((li) => {
+        const text = li.textContent?.trim() ?? "";
+        if (text)
+          items.push(text);
+      });
+      if (items.length >= 3) {
+        const tag = list.tagName.toLowerCase();
+        result.lists.push({ items, selector: `${tag}:nth-of-type(${idx + 1})` });
+      }
+    });
+    document.querySelectorAll('script[type="application/ld+json"]').forEach((script) => {
+      try {
+        result.jsonLd.push(JSON.parse(script.textContent ?? ""));
+      } catch {}
+    });
+    document.querySelectorAll('meta[property^="og:"]').forEach((meta) => {
+      const prop = meta.getAttribute("property")?.replace("og:", "") ?? "";
+      result.openGraph[prop] = meta.getAttribute("content") ?? "";
+    });
+    document.querySelectorAll("meta[name]").forEach((meta) => {
+      const name = meta.getAttribute("name") ?? "";
+      if (name)
+        result.metaTags[name] = meta.getAttribute("content") ?? "";
+    });
+    const classCounts = new Map;
+    document.querySelectorAll("[class]").forEach((el) => {
+      const cls = el.className.toString().trim();
+      if (cls && cls.length > 5 && cls.length < 100) {
+        if (!classCounts.has(cls))
+          classCounts.set(cls, []);
+        classCounts.get(cls).push(el);
+      }
+    });
+    for (const [cls, elements] of classCounts) {
+      if (elements.length >= 3 && elements.length <= 200) {
+        const sample = elements.slice(0, 3).map((el) => el.textContent?.trim().slice(0, 100) ?? "");
+        if (sample.some((s) => s.length > 10)) {
+          result.repeatedElements.push({
+            selector: `.${cls.split(" ")[0]}`,
+            count: elements.length,
+            sample
+          });
+        }
+      }
+    }
+    result.repeatedElements.sort((a, b) => b.count - a.count);
+    result.repeatedElements = result.repeatedElements.slice(0, 10);
+    return result;
+  });
+}
+
+// src/lib/gallery-diff.ts
+var exports_gallery_diff = {};
+__export(exports_gallery_diff, {
+  diffImages: () => diffImages
+});
+import { join as join5 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+async function diffImages(path1, path2) {
+  const img1 = import_sharp2.default(path1);
+  const img2 = import_sharp2.default(path2);
+  const [meta1, meta2] = await Promise.all([img1.metadata(), img2.metadata()]);
+  const w = Math.min(meta1.width ?? 1280, meta2.width ?? 1280);
+  const h = Math.min(meta1.height ?? 720, meta2.height ?? 720);
+  const [raw1, raw2] = await Promise.all([
+    import_sharp2.default(path1).resize(w, h, { fit: "fill" }).raw().toBuffer(),
+    import_sharp2.default(path2).resize(w, h, { fit: "fill" }).raw().toBuffer()
+  ]);
+  const totalPixels = w * h;
+  const channels = 3;
+  const diffBuffer = Buffer.alloc(raw1.length);
+  let changedPixels = 0;
+  for (let i = 0;i < raw1.length; i += channels) {
+    const dr = Math.abs(raw1[i] - raw2[i]);
+    const dg = Math.abs(raw1[i + 1] - raw2[i + 1]);
+    const db = Math.abs(raw1[i + 2] - raw2[i + 2]);
+    const diff = (dr + dg + db) / 3;
+    if (diff > 10) {
+      changedPixels++;
+      diffBuffer[i] = 255;
+      diffBuffer[i + 1] = 0;
+      diffBuffer[i + 2] = 0;
+    } else {
+      diffBuffer[i] = Math.round(raw1[i] * 0.4);
+      diffBuffer[i + 1] = Math.round(raw1[i + 1] * 0.4);
+      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 diffImageBuffer = await import_sharp2.default(diffBuffer, { raw: { width: w, height: h, channels } }).webp({ quality: 85 }).toBuffer();
+  await Bun.write(diffPath, diffImageBuffer);
+  return {
+    diff_path: diffPath,
+    diff_base64: diffImageBuffer.toString("base64"),
+    changed_pixels: changedPixels,
+    total_pixels: totalPixels,
+    changed_percent: changedPixels / totalPixels * 100
+  };
+}
+var import_sharp2;
+var init_gallery_diff = __esm(() => {
+  import_sharp2 = __toESM(require_lib(), 1);
+});
+
+// src/lib/profiles.ts
+var exports_profiles = {};
+__export(exports_profiles, {
+  saveProfile: () => saveProfile,
+  loadProfile: () => loadProfile,
+  listProfiles: () => listProfiles,
+  deleteProfile: () => deleteProfile,
+  applyProfile: () => applyProfile
+});
+import { mkdirSync as mkdirSync6, existsSync as existsSync3, readdirSync as readdirSync2, rmSync, readFileSync, writeFileSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir6 } from "os";
+function getProfilesDir() {
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join6(homedir6(), ".browser");
+  const dir = join6(dataDir, "profiles");
+  mkdirSync6(dir, { recursive: true });
+  return dir;
+}
+function getProfileDir2(name) {
+  return join6(getProfilesDir(), name);
+}
+async function saveProfile(page, name) {
+  const dir = getProfileDir2(name);
+  mkdirSync6(dir, { recursive: true });
+  const cookies = await page.context().cookies();
+  writeFileSync(join6(dir, "cookies.json"), JSON.stringify(cookies, null, 2));
+  let localStorage2 = {};
+  try {
+    localStorage2 = await page.evaluate(() => {
+      const result = {};
+      for (let i = 0;i < window.localStorage.length; i++) {
+        const key = window.localStorage.key(i);
+        result[key] = window.localStorage.getItem(key);
+      }
+      return result;
+    });
+  } catch {}
+  writeFileSync(join6(dir, "storage.json"), JSON.stringify(localStorage2, null, 2));
+  const savedAt = new Date().toISOString();
+  const url = page.url();
+  const meta = { saved_at: savedAt, url };
+  writeFileSync(join6(dir, "meta.json"), JSON.stringify(meta, null, 2));
+  return {
+    name,
+    saved_at: savedAt,
+    url,
+    cookie_count: cookies.length,
+    storage_key_count: Object.keys(localStorage2).length
+  };
+}
+function loadProfile(name) {
+  const dir = getProfileDir2(name);
+  if (!existsSync3(dir)) {
+    throw new Error(`Profile not found: ${name}`);
+  }
+  const cookiesPath = join6(dir, "cookies.json");
+  const storagePath = join6(dir, "storage.json");
+  const metaPath = join6(dir, "meta.json");
+  const cookies = existsSync3(cookiesPath) ? JSON.parse(readFileSync(cookiesPath, "utf8")) : [];
+  const localStorage2 = existsSync3(storagePath) ? JSON.parse(readFileSync(storagePath, "utf8")) : {};
+  let savedAt = new Date().toISOString();
+  let url;
+  if (existsSync3(metaPath)) {
+    const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+    savedAt = meta.saved_at ?? savedAt;
+    url = meta.url;
+  }
+  return { cookies, localStorage: localStorage2, saved_at: savedAt, url };
+}
+async function applyProfile(page, profileData) {
+  if (profileData.cookies.length > 0) {
+    await page.context().addCookies(profileData.cookies);
+  }
+  const storageKeys = Object.keys(profileData.localStorage);
+  if (storageKeys.length > 0) {
+    try {
+      await page.evaluate((storage) => {
+        for (const [key, value] of Object.entries(storage)) {
+          window.localStorage.setItem(key, value);
+        }
+      }, profileData.localStorage);
+    } catch {}
+  }
+  return {
+    cookies_applied: profileData.cookies.length,
+    storage_keys_applied: storageKeys.length
+  };
+}
+function listProfiles() {
+  const dir = getProfilesDir();
+  if (!existsSync3(dir))
+    return [];
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  const profiles = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const name = entry.name;
+    const profileDir = join6(dir, name);
+    let savedAt = "";
+    let url;
+    let cookieCount = 0;
+    let storageKeyCount = 0;
+    try {
+      const metaPath = join6(profileDir, "meta.json");
+      if (existsSync3(metaPath)) {
+        const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+        savedAt = meta.saved_at ?? "";
+        url = meta.url;
+      }
+      const cookiesPath = join6(profileDir, "cookies.json");
+      if (existsSync3(cookiesPath)) {
+        const cookies = JSON.parse(readFileSync(cookiesPath, "utf8"));
+        cookieCount = Array.isArray(cookies) ? cookies.length : 0;
+      }
+      const storagePath = join6(profileDir, "storage.json");
+      if (existsSync3(storagePath)) {
+        const storage = JSON.parse(readFileSync(storagePath, "utf8"));
+        storageKeyCount = Object.keys(storage).length;
+      }
+    } catch {}
+    profiles.push({
+      name,
+      saved_at: savedAt,
+      url,
+      cookie_count: cookieCount,
+      storage_key_count: storageKeyCount
+    });
+  }
+  return profiles.sort((a, b) => b.saved_at.localeCompare(a.saved_at));
+}
+function deleteProfile(name) {
+  const dir = getProfileDir2(name);
+  if (!existsSync3(dir))
+    return false;
+  try {
+    rmSync(dir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_profiles = () => {};
+
+// src/lib/auth.ts
+var exports_auth = {};
+__export(exports_auth, {
+  loginWithCredentials: () => loginWithCredentials,
+  getCredentials: () => getCredentials
+});
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
+async function getCredentials(service) {
+  try {
+    const { getSecret } = await import(`${homedir7()}/Workspace/hasna/opensource/opensourcedev/open-secrets/src/store.js`);
+    const email = getSecret(`${service}_email`) ?? getSecret(`${service}_username`) ?? getSecret(`${service}_login`);
+    const password = getSecret(`${service}_password`) ?? getSecret(`${service}_pass`);
+    if (email?.value && password?.value) {
+      return { email: email.value, password: password.value };
+    }
+  } catch {}
+  const secretsPath = join7(homedir7(), ".secrets");
+  if (existsSync4(secretsPath)) {
+    const content = readFileSync2(secretsPath, "utf8");
+    const lines = content.split(`
+`);
+    const prefix = service.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    const vars = {};
+    for (const line of lines) {
+      const match = line.match(/^export\s+([A-Z_]+)=["']?(.+?)["']?\s*$/);
+      if (match)
+        vars[match[1]] = match[2];
+    }
+    const email = vars[`${prefix}_EMAIL`] ?? vars[`${prefix}_USERNAME`];
+    const password = vars[`${prefix}_PASSWORD`];
+    if (email && password)
+      return { email, password };
+  }
+  const envPrefix = service.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  const envEmail = process.env[`${envPrefix}_EMAIL`] ?? process.env[`${envPrefix}_USERNAME`];
+  const envPass = process.env[`${envPrefix}_PASSWORD`];
+  if (envEmail && envPass)
+    return { email: envEmail, password: envPass };
+  return null;
+}
+async function loginWithCredentials(page, credentials, opts) {
+  const { fillForm: fillForm2 } = await Promise.resolve().then(() => (init_actions(), exports_actions));
+  const { saveProfile: saveProfile2 } = await Promise.resolve().then(() => (init_profiles(), exports_profiles));
+  try {
+    if (opts?.loginUrl) {
+      await page.goto(opts.loginUrl, { waitUntil: "domcontentloaded" });
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    const emailSel = opts?.emailSelector ?? 'input[type="email"], input[name="email"], input[id*="email"], input[placeholder*="email" i]';
+    const passSel = opts?.passwordSelector ?? 'input[type="password"]';
+    const submitSel = opts?.submitSelector ?? 'button[type="submit"], input[type="submit"], button:contains("Sign in"), button:contains("Log in"), button:contains("Login")';
+    const fields = {};
+    if (credentials.email)
+      fields[emailSel] = credentials.email;
+    else if (credentials.username)
+      fields[emailSel] = credentials.username;
+    if (credentials.password)
+      fields[passSel] = credentials.password;
+    const fillResult = await fillForm2(page, fields, submitSel);
+    const successText = opts?.waitForText ?? "dashboard|profile|account|welcome|signed in|logout";
+    await new Promise((r) => setTimeout(r, 1500));
+    const currentUrl = page.url?.() ?? "";
+    const logged_in = fillResult.errors.length === 0;
+    let profile_saved = false;
+    if (opts?.saveProfile && logged_in) {
+      try {
+        await saveProfile2(page, opts.saveProfile);
+        profile_saved = true;
+      } catch {}
+    }
+    return {
+      logged_in,
+      redirect_url: currentUrl,
+      profile_saved,
+      method: "secrets_vault"
+    };
+  } catch (err) {
+    return {
+      logged_in: false,
+      redirect_url: "",
+      profile_saved: false,
+      method: "not_found",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var init_auth = () => {};
+
+// src/lib/daemon-client.ts
+var exports_daemon_client = {};
+__export(exports_daemon_client, {
+  isDaemonRunning: () => isDaemonRunning,
+  getDaemonStatus: () => getDaemonStatus,
+  getDaemonPort: () => getDaemonPort,
+  getDaemonPidFile: () => getDaemonPidFile,
+  getDaemonPid: () => getDaemonPid
+});
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
+function getDaemonPidFile() {
+  return PID_FILE;
+}
+function getDaemonPort() {
+  return parseInt(process.env["BROWSER_DAEMON_PORT"] ?? String(DEFAULT_PORT), 10);
+}
+function isDaemonRunning() {
+  if (!existsSync5(PID_FILE))
+    return false;
+  try {
+    const pid = parseInt(readFileSync3(PID_FILE, "utf8").trim(), 10);
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDaemonPid() {
+  if (!existsSync5(PID_FILE))
+    return null;
+  try {
+    return parseInt(readFileSync3(PID_FILE, "utf8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+async function getDaemonStatus() {
+  const pid = getDaemonPid();
+  const port = getDaemonPort();
+  if (!isDaemonRunning())
+    return { running: false, pid: null, port };
+  try {
+    const res = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(2000) });
+    const data = await res.json();
+    return { running: true, pid, port, sessions: data.active_sessions ?? 0, uptime_ms: data.uptime_ms };
+  } catch {
+    return { running: true, pid, port };
+  }
+}
+var PID_FILE, DEFAULT_PORT = 7030;
+var init_daemon_client = __esm(() => {
+  PID_FILE = join8(process.env["BROWSER_DATA_DIR"] ?? join8(homedir8(), ".browser"), "daemon.pid");
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -16186,17 +16971,17 @@ __export(exports_downloads, {
   deleteDownload: () => deleteDownload,
   cleanStaleDownloads: () => cleanStaleDownloads
 });
-import { randomUUID as randomUUID9 } from "crypto";
-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";
+import { randomUUID as randomUUID10 } from "crypto";
+import { join as join9, basename, extname } from "path";
+import { mkdirSync as mkdirSync7, existsSync as existsSync6, readdirSync as readdirSync3, statSync, unlinkSync as unlinkSync2, copyFileSync, writeFileSync as writeFileSync2, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir9 } from "os";
 function getDataDir3() {
-  return process.env["BROWSER_DATA_DIR"] ?? join5(homedir5(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join9(homedir9(), ".browser");
 }
 function getDownloadsDir(sessionId) {
-  const base = join5(getDataDir3(), "downloads");
-  const dir = sessionId ? join5(base, sessionId) : base;
-  mkdirSync5(dir, { recursive: true });
+  const base = join9(getDataDir3(), "downloads");
+  const dir = sessionId ? join9(base, sessionId) : base;
+  mkdirSync7(dir, { recursive: true });
   return dir;
 }
 function ensureDownloadsDir() {
@@ -16207,12 +16992,12 @@ function metaPath(filePath) {
 }
 function saveToDownloads(buffer, filename, opts) {
   const dir = getDownloadsDir(opts?.sessionId);
-  const id = randomUUID9();
+  const id = randomUUID10();
   const ext = extname(filename) || "";
   const stem = basename(filename, ext);
   const uniqueName = `${stem}-${id.slice(0, 8)}${ext}`;
-  const filePath = join5(dir, uniqueName);
-  writeFileSync(filePath, buffer);
+  const filePath = join9(dir, uniqueName);
+  writeFileSync2(filePath, buffer);
   const meta = {
     id,
     type: opts?.type ?? detectType(filename),
@@ -16223,7 +17008,7 @@ function saveToDownloads(buffer, filename, opts) {
     original_name: filename,
     ...opts?.metadata
   };
-  writeFileSync(metaPath(filePath), JSON.stringify(meta, null, 2));
+  writeFileSync2(metaPath(filePath), JSON.stringify(meta, null, 2));
   return {
     id,
     path: filePath,
@@ -16240,23 +17025,23 @@ function listDownloads(sessionId) {
   const dir = getDownloadsDir(sessionId);
   const results = [];
   function scanDir(d) {
-    if (!existsSync2(d))
+    if (!existsSync6(d))
       return;
-    const entries = readdirSync2(d);
+    const entries = readdirSync3(d);
     for (const entry of entries) {
       if (entry.endsWith(".meta.json"))
         continue;
-      const full = join5(d, entry);
+      const full = join9(d, entry);
       const stat = statSync(full);
       if (stat.isDirectory()) {
         scanDir(full);
         continue;
       }
       const mpath = metaPath(full);
-      if (!existsSync2(mpath))
+      if (!existsSync6(mpath))
         continue;
       try {
-        const meta = JSON.parse(readFileSync(mpath, "utf8"));
+        const meta = JSON.parse(readFileSync4(mpath, "utf8"));
         results.push({
           id: meta.id,
           path: full,
@@ -16284,7 +17069,7 @@ function deleteDownload(id, sessionId) {
     return false;
   try {
     unlinkSync2(file.path);
-    if (existsSync2(file.meta_path))
+    if (existsSync6(file.meta_path))
       unlinkSync2(file.meta_path);
     return true;
   } catch {
@@ -16330,67 +17115,10 @@ function detectType(filename) {
 }
 var init_downloads = () => {};
 
-// src/lib/gallery-diff.ts
-var exports_gallery_diff = {};
-__export(exports_gallery_diff, {
-  diffImages: () => diffImages
-});
-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);
-  const [meta1, meta2] = await Promise.all([img1.metadata(), img2.metadata()]);
-  const w = Math.min(meta1.width ?? 1280, meta2.width ?? 1280);
-  const h = Math.min(meta1.height ?? 720, meta2.height ?? 720);
-  const [raw1, raw2] = await Promise.all([
-    import_sharp2.default(path1).resize(w, h, { fit: "fill" }).raw().toBuffer(),
-    import_sharp2.default(path2).resize(w, h, { fit: "fill" }).raw().toBuffer()
-  ]);
-  const totalPixels = w * h;
-  const channels = 3;
-  const diffBuffer = Buffer.alloc(raw1.length);
-  let changedPixels = 0;
-  for (let i = 0;i < raw1.length; i += channels) {
-    const dr = Math.abs(raw1[i] - raw2[i]);
-    const dg = Math.abs(raw1[i + 1] - raw2[i + 1]);
-    const db = Math.abs(raw1[i + 2] - raw2[i + 2]);
-    const diff = (dr + dg + db) / 3;
-    if (diff > 10) {
-      changedPixels++;
-      diffBuffer[i] = 255;
-      diffBuffer[i + 1] = 0;
-      diffBuffer[i + 2] = 0;
-    } else {
-      diffBuffer[i] = Math.round(raw1[i] * 0.4);
-      diffBuffer[i + 1] = Math.round(raw1[i + 1] * 0.4);
-      diffBuffer[i + 2] = Math.round(raw1[i + 2] * 0.4);
-    }
-  }
-  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 {
-    diff_path: diffPath,
-    diff_base64: diffImageBuffer.toString("base64"),
-    changed_pixels: changedPixels,
-    total_pixels: totalPixels,
-    changed_percent: changedPixels / totalPixels * 100
-  };
-}
-var import_sharp2;
-var init_gallery_diff = __esm(() => {
-  import_sharp2 = __toESM(require_lib(), 1);
-});
-
 // src/lib/files-integration.ts
-import { join as join7 } from "path";
-import { mkdirSync as mkdirSync7, copyFileSync as copyFileSync2 } from "fs";
-import { homedir as homedir7 } from "os";
+import { join as join10 } from "path";
+import { mkdirSync as mkdirSync8, copyFileSync as copyFileSync2 } from "fs";
+import { homedir as homedir10 } from "os";
 async function persistFile(localPath, opts) {
   try {
     const mod = await import("@hasna/files");
@@ -16399,12 +17127,12 @@ async function persistFile(localPath, opts) {
       return { id: ref.id, path: ref.path ?? localPath, permanent: true, provider: "open-files" };
     }
   } catch {}
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join7(homedir7(), ".browser");
+  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join10(homedir10(), ".browser");
   const date = new Date().toISOString().split("T")[0];
-  const dir = join7(dataDir, "persistent", date);
-  mkdirSync7(dir, { recursive: true });
+  const dir = join10(dataDir, "persistent", date);
+  mkdirSync8(dir, { recursive: true });
   const filename = localPath.split("/").pop() ?? "file";
-  const targetPath = join7(dir, filename);
+  const targetPath = join10(dir, filename);
   copyFileSync2(localPath, targetPath);
   return {
     id: `local-${Date.now()}`,
@@ -16510,150 +17238,6 @@ async function closeTab(page, index) {
   };
 }
 
-// src/lib/profiles.ts
-var exports_profiles = {};
-__export(exports_profiles, {
-  saveProfile: () => saveProfile,
-  loadProfile: () => loadProfile,
-  listProfiles: () => listProfiles,
-  deleteProfile: () => deleteProfile,
-  applyProfile: () => applyProfile
-});
-import { mkdirSync as mkdirSync8, existsSync as existsSync4, readdirSync as readdirSync3, rmSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
-function getProfilesDir() {
-  const dataDir = process.env["BROWSER_DATA_DIR"] ?? join8(homedir8(), ".browser");
-  const dir = join8(dataDir, "profiles");
-  mkdirSync8(dir, { recursive: true });
-  return dir;
-}
-function getProfileDir2(name) {
-  return join8(getProfilesDir(), name);
-}
-async function saveProfile(page, name) {
-  const dir = getProfileDir2(name);
-  mkdirSync8(dir, { recursive: true });
-  const cookies = await page.context().cookies();
-  writeFileSync2(join8(dir, "cookies.json"), JSON.stringify(cookies, null, 2));
-  let localStorage2 = {};
-  try {
-    localStorage2 = await page.evaluate(() => {
-      const result = {};
-      for (let i = 0;i < window.localStorage.length; i++) {
-        const key = window.localStorage.key(i);
-        result[key] = window.localStorage.getItem(key);
-      }
-      return result;
-    });
-  } catch {}
-  writeFileSync2(join8(dir, "storage.json"), JSON.stringify(localStorage2, null, 2));
-  const savedAt = new Date().toISOString();
-  const url = page.url();
-  const meta = { saved_at: savedAt, url };
-  writeFileSync2(join8(dir, "meta.json"), JSON.stringify(meta, null, 2));
-  return {
-    name,
-    saved_at: savedAt,
-    url,
-    cookie_count: cookies.length,
-    storage_key_count: Object.keys(localStorage2).length
-  };
-}
-function loadProfile(name) {
-  const dir = getProfileDir2(name);
-  if (!existsSync4(dir)) {
-    throw new Error(`Profile not found: ${name}`);
-  }
-  const cookiesPath = join8(dir, "cookies.json");
-  const storagePath = join8(dir, "storage.json");
-  const metaPath2 = join8(dir, "meta.json");
-  const cookies = existsSync4(cookiesPath) ? JSON.parse(readFileSync2(cookiesPath, "utf8")) : [];
-  const localStorage2 = existsSync4(storagePath) ? JSON.parse(readFileSync2(storagePath, "utf8")) : {};
-  let savedAt = new Date().toISOString();
-  let url;
-  if (existsSync4(metaPath2)) {
-    const meta = JSON.parse(readFileSync2(metaPath2, "utf8"));
-    savedAt = meta.saved_at ?? savedAt;
-    url = meta.url;
-  }
-  return { cookies, localStorage: localStorage2, saved_at: savedAt, url };
-}
-async function applyProfile(page, profileData) {
-  if (profileData.cookies.length > 0) {
-    await page.context().addCookies(profileData.cookies);
-  }
-  const storageKeys = Object.keys(profileData.localStorage);
-  if (storageKeys.length > 0) {
-    try {
-      await page.evaluate((storage) => {
-        for (const [key, value] of Object.entries(storage)) {
-          window.localStorage.setItem(key, value);
-        }
-      }, profileData.localStorage);
-    } catch {}
-  }
-  return {
-    cookies_applied: profileData.cookies.length,
-    storage_keys_applied: storageKeys.length
-  };
-}
-function listProfiles() {
-  const dir = getProfilesDir();
-  if (!existsSync4(dir))
-    return [];
-  const entries = readdirSync3(dir, { withFileTypes: true });
-  const profiles = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const name = entry.name;
-    const profileDir = join8(dir, name);
-    let savedAt = "";
-    let url;
-    let cookieCount = 0;
-    let storageKeyCount = 0;
-    try {
-      const metaPath2 = join8(profileDir, "meta.json");
-      if (existsSync4(metaPath2)) {
-        const meta = JSON.parse(readFileSync2(metaPath2, "utf8"));
-        savedAt = meta.saved_at ?? "";
-        url = meta.url;
-      }
-      const cookiesPath = join8(profileDir, "cookies.json");
-      if (existsSync4(cookiesPath)) {
-        const cookies = JSON.parse(readFileSync2(cookiesPath, "utf8"));
-        cookieCount = Array.isArray(cookies) ? cookies.length : 0;
-      }
-      const storagePath = join8(profileDir, "storage.json");
-      if (existsSync4(storagePath)) {
-        const storage = JSON.parse(readFileSync2(storagePath, "utf8"));
-        storageKeyCount = Object.keys(storage).length;
-      }
-    } catch {}
-    profiles.push({
-      name,
-      saved_at: savedAt,
-      url,
-      cookie_count: cookieCount,
-      storage_key_count: storageKeyCount
-    });
-  }
-  return profiles.sort((a, b) => b.saved_at.localeCompare(a.saved_at));
-}
-function deleteProfile(name) {
-  const dir = getProfileDir2(name);
-  if (!existsSync4(dir))
-    return false;
-  try {
-    rmSync(dir, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var init_profiles = () => {};
-
 // src/lib/sanitize.ts
 var exports_sanitize = {};
 __export(exports_sanitize, {
@@ -16805,6 +17389,166 @@ var init_annotate = __esm(() => {
   import_sharp3 = __toESM(require_lib(), 1);
 });
 
+// src/lib/workflows.ts
+var exports_workflows = {};
+__export(exports_workflows, {
+  saveWorkflowFromRecording: () => saveWorkflowFromRecording,
+  saveWorkflow: () => saveWorkflow,
+  runWorkflow: () => runWorkflow,
+  listWorkflows: () => listWorkflows,
+  getWorkflowByName: () => getWorkflowByName,
+  getWorkflow: () => getWorkflow,
+  deleteWorkflow: () => deleteWorkflow
+});
+import { randomUUID as randomUUID11 } from "crypto";
+function saveWorkflow(data) {
+  const db = getDatabase();
+  const id = randomUUID11();
+  db.prepare("INSERT OR REPLACE INTO workflows (id, name, description, steps, start_url) VALUES (?, ?, ?, ?, ?)").run(id, data.name, data.description ?? null, JSON.stringify(data.steps), data.startUrl ?? null);
+  return getWorkflow(id);
+}
+function saveWorkflowFromRecording(recordingId, name, description) {
+  const db = getDatabase();
+  const rec = db.query("SELECT steps, start_url FROM recordings WHERE id = ?").get(recordingId);
+  if (!rec)
+    throw new Error(`Recording not found: ${recordingId}`);
+  const steps = JSON.parse(rec.steps);
+  return saveWorkflow({ name, description, steps, startUrl: rec.start_url ?? undefined });
+}
+function getWorkflow(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM workflows WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return { ...row, steps: JSON.parse(row.steps) };
+}
+function getWorkflowByName(name) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM workflows WHERE name = ?").get(name);
+  if (!row)
+    return null;
+  return { ...row, steps: JSON.parse(row.steps) };
+}
+function listWorkflows() {
+  const db = getDatabase();
+  return db.query("SELECT * FROM workflows ORDER BY updated_at DESC").all().map((row) => ({ ...row, steps: JSON.parse(row.steps) }));
+}
+function deleteWorkflow(name) {
+  const db = getDatabase();
+  return db.prepare("DELETE FROM workflows WHERE name = ?").run(name).changes > 0;
+}
+function recordRun(id, healed) {
+  const db = getDatabase();
+  if (healed) {
+    db.prepare("UPDATE workflows SET last_run = datetime('now'), last_heal = datetime('now'), heal_count = heal_count + 1, run_count = run_count + 1, updated_at = datetime('now') WHERE id = ?").run(id);
+  } else {
+    db.prepare("UPDATE workflows SET last_run = datetime('now'), run_count = run_count + 1, updated_at = datetime('now') WHERE id = ?").run(id);
+  }
+}
+async function runWorkflow(workflow, page) {
+  const t0 = Date.now();
+  let executed = 0;
+  let failed = 0;
+  let healed = 0;
+  const healedDetails = [];
+  const errors2 = [];
+  const updatedSteps = [...workflow.steps];
+  for (let i = 0;i < workflow.steps.length; i++) {
+    const step = workflow.steps[i];
+    try {
+      switch (step.type) {
+        case "navigate":
+          if (step.url)
+            await page.goto(step.url, { waitUntil: "domcontentloaded", timeout: 30000 });
+          break;
+        case "click":
+          if (step.selector) {
+            try {
+              await page.click(step.selector, { timeout: 5000 });
+            } catch {
+              const result = await healSelector(page, step.selector);
+              if (result.found && result.locator) {
+                await result.locator.click();
+                healed++;
+                const healedSelector = `[healed:${result.method}]${step.selector}`;
+                healedDetails.push({ step: i, original: step.selector, healed_to: healedSelector, method: result.method });
+              } else {
+                throw new Error(`Click failed: ${step.selector} (self-healing exhausted)`);
+              }
+            }
+          }
+          break;
+        case "type":
+          if (step.selector && step.value) {
+            try {
+              await page.fill(step.selector, step.value);
+            } catch {
+              const result = await healSelector(page, step.selector);
+              if (result.found && result.locator) {
+                await result.locator.fill(step.value);
+                healed++;
+                healedDetails.push({ step: i, original: step.selector, healed_to: `[healed:${result.method}]`, method: result.method });
+              } else {
+                throw new Error(`Type failed: ${step.selector} (self-healing exhausted)`);
+              }
+            }
+          }
+          break;
+        case "scroll":
+          if (step.y)
+            await page.mouse.wheel(0, step.y);
+          break;
+        case "hover":
+          if (step.selector) {
+            try {
+              await page.hover(step.selector);
+            } catch {}
+          }
+          break;
+        case "select":
+          if (step.selector && step.value) {
+            try {
+              await page.selectOption(step.selector, step.value);
+            } catch {}
+          }
+          break;
+        case "wait":
+          if (step.selector) {
+            try {
+              await page.waitForSelector(step.selector, { timeout: 1e4 });
+            } catch {}
+          } else {
+            await new Promise((r) => setTimeout(r, step.timestamp || 1000));
+          }
+          break;
+        case "evaluate":
+          if (step.value)
+            await page.evaluate(step.value);
+          break;
+        default:
+          break;
+      }
+      executed++;
+    } catch (err) {
+      failed++;
+      errors2.push(`Step ${i} (${step.type}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  recordRun(workflow.id, healed > 0);
+  return {
+    success: failed === 0,
+    steps_executed: executed,
+    steps_failed: failed,
+    steps_healed: healed,
+    healed_details: healedDetails,
+    errors: errors2,
+    duration_ms: Date.now() - t0
+  };
+}
+var init_workflows = __esm(() => {
+  init_schema();
+});
+
 // src/lib/auth-flow.ts
 var exports_auth_flow = {};
 __export(exports_auth_flow, {
@@ -16819,10 +17563,10 @@ __export(exports_auth_flow, {
   getAuthFlow: () => getAuthFlow,
   deleteAuthFlow: () => deleteAuthFlow
 });
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function saveAuthFlow(data) {
   const db = getDatabase();
-  const id = randomUUID10();
+  const id = randomUUID12();
   db.prepare("INSERT OR REPLACE INTO auth_flows (id, name, domain, recording_id, storage_state_path) VALUES (?, ?, ?, ?, ?)").run(id, data.name, data.domain, data.recordingId ?? null, data.storageStatePath ?? null);
   return getAuthFlow(id);
 }
@@ -16865,9 +17609,9 @@ async function tryReplayAuth(page, domain) {
     return { replayed: false };
   if (flow.storage_state_path) {
     try {
-      const { existsSync: existsSync5, readFileSync: readFileSync3 } = await import("fs");
-      if (existsSync5(flow.storage_state_path)) {
-        const state = JSON.parse(readFileSync3(flow.storage_state_path, "utf8"));
+      const { existsSync: existsSync7, readFileSync: readFileSync5 } = await import("fs");
+      if (existsSync7(flow.storage_state_path)) {
+        const state = JSON.parse(readFileSync5(flow.storage_state_path, "utf8"));
         if (state.cookies?.length) {
           await page.context().addCookies(state.cookies);
           await page.reload();
@@ -16992,95 +17736,88 @@ async function clickByVision(page, description, opts) {
 }
 var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 
-// src/lib/auth.ts
-var exports_auth = {};
-__export(exports_auth, {
-  loginWithCredentials: () => loginWithCredentials,
-  getCredentials: () => getCredentials
+// src/lib/datasets.ts
+var exports_datasets = {};
+__export(exports_datasets, {
+  saveDataset: () => saveDataset,
+  listDatasets: () => listDatasets,
+  getDatasetByName: () => getDatasetByName,
+  getDataset: () => getDataset,
+  exportDataset: () => exportDataset,
+  deleteDataset: () => deleteDataset
 });
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir9 } from "os";
-async function getCredentials(service) {
-  try {
-    const { getSecret } = await import(`${homedir9()}/Workspace/hasna/opensource/opensourcedev/open-secrets/src/store.js`);
-    const email = getSecret(`${service}_email`) ?? getSecret(`${service}_username`) ?? getSecret(`${service}_login`);
-    const password = getSecret(`${service}_password`) ?? getSecret(`${service}_pass`);
-    if (email?.value && password?.value) {
-      return { email: email.value, password: password.value };
-    }
-  } catch {}
-  const secretsPath = join9(homedir9(), ".secrets");
-  if (existsSync5(secretsPath)) {
-    const content = readFileSync3(secretsPath, "utf8");
-    const lines = content.split(`
-`);
-    const prefix = service.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-    const vars = {};
-    for (const line of lines) {
-      const match = line.match(/^export\s+([A-Z_]+)=["']?(.+?)["']?\s*$/);
-      if (match)
-        vars[match[1]] = match[2];
-    }
-    const email = vars[`${prefix}_EMAIL`] ?? vars[`${prefix}_USERNAME`];
-    const password = vars[`${prefix}_PASSWORD`];
-    if (email && password)
-      return { email, password };
+import { randomUUID as randomUUID13 } from "crypto";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync9 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir11 } from "os";
+function saveDataset(data) {
+  const db = getDatabase();
+  const id = randomUUID13();
+  const existing = db.query("SELECT id FROM datasets WHERE name = ?").get(data.name);
+  if (existing) {
+    db.prepare("UPDATE datasets SET data = ?, row_count = ?, source_url = ?, schema = ?, last_refresh = datetime('now'), updated_at = datetime('now') WHERE name = ?").run(JSON.stringify(data.rows), data.rows.length, data.sourceUrl ?? null, data.schema ? JSON.stringify(data.schema) : null, data.name);
+    return getDataset(existing.id);
   }
-  const envPrefix = service.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  const envEmail = process.env[`${envPrefix}_EMAIL`] ?? process.env[`${envPrefix}_USERNAME`];
-  const envPass = process.env[`${envPrefix}_PASSWORD`];
-  if (envEmail && envPass)
-    return { email: envEmail, password: envPass };
-  return null;
+  db.prepare("INSERT INTO datasets (id, name, source_url, source_type, data, row_count, schema) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, data.name, data.sourceUrl ?? null, data.sourceType ?? "page", JSON.stringify(data.rows), data.rows.length, data.schema ? JSON.stringify(data.schema) : null);
+  return getDataset(id);
 }
-async function loginWithCredentials(page, credentials, opts) {
-  const { fillForm: fillForm2 } = await Promise.resolve().then(() => (init_actions(), exports_actions));
-  const { saveProfile: saveProfile2 } = await Promise.resolve().then(() => (init_profiles(), exports_profiles));
-  try {
-    if (opts?.loginUrl) {
-      await page.goto(opts.loginUrl, { waitUntil: "domcontentloaded" });
-      await new Promise((r) => setTimeout(r, 500));
+function getDataset(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM datasets WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return { ...row, data: JSON.parse(row.data), schema: row.schema ? JSON.parse(row.schema) : null };
+}
+function getDatasetByName(name) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM datasets WHERE name = ?").get(name);
+  if (!row)
+    return null;
+  return { ...row, data: JSON.parse(row.data), schema: row.schema ? JSON.parse(row.schema) : null };
+}
+function listDatasets() {
+  const db = getDatabase();
+  return db.query("SELECT id, name, source_url, source_type, row_count, last_refresh, created_at, updated_at FROM datasets ORDER BY updated_at DESC").all().map((row) => ({ ...row, data: `${row.row_count} rows`, schema: null }));
+}
+function deleteDataset(name) {
+  const db = getDatabase();
+  return db.prepare("DELETE FROM datasets WHERE name = ?").run(name).changes > 0;
+}
+function exportDataset(name, format) {
+  const dataset = getDatasetByName(name);
+  if (!dataset)
+    throw new Error(`Dataset '${name}' not found`);
+  const dir = join11(process.env["BROWSER_DATA_DIR"] ?? join11(homedir11(), ".browser"), "exports");
+  mkdirSync9(dir, { recursive: true });
+  const filename = `${name}.${format}`;
+  const path = join11(dir, filename);
+  if (format === "csv") {
+    const rows = dataset.data;
+    if (rows.length === 0) {
+      writeFileSync3(path, "");
+      return { path, size: 0 };
     }
-    const emailSel = opts?.emailSelector ?? 'input[type="email"], input[name="email"], input[id*="email"], input[placeholder*="email" i]';
-    const passSel = opts?.passwordSelector ?? 'input[type="password"]';
-    const submitSel = opts?.submitSelector ?? 'button[type="submit"], input[type="submit"], button:contains("Sign in"), button:contains("Log in"), button:contains("Login")';
-    const fields = {};
-    if (credentials.email)
-      fields[emailSel] = credentials.email;
-    else if (credentials.username)
-      fields[emailSel] = credentials.username;
-    if (credentials.password)
-      fields[passSel] = credentials.password;
-    const fillResult = await fillForm2(page, fields, submitSel);
-    const successText = opts?.waitForText ?? "dashboard|profile|account|welcome|signed in|logout";
-    await new Promise((r) => setTimeout(r, 1500));
-    const currentUrl = page.url?.() ?? "";
-    const logged_in = fillResult.errors.length === 0;
-    let profile_saved = false;
-    if (opts?.saveProfile && logged_in) {
-      try {
-        await saveProfile2(page, opts.saveProfile);
-        profile_saved = true;
-      } catch {}
+    const headers = Object.keys(rows[0]);
+    const csvLines = [headers.join(",")];
+    for (const row of rows) {
+      csvLines.push(headers.map((h) => {
+        const val = String(row[h] ?? "");
+        return val.includes(",") || val.includes('"') ? `"${val.replace(/"/g, '""')}"` : val;
+      }).join(","));
     }
-    return {
-      logged_in,
-      redirect_url: currentUrl,
-      profile_saved,
-      method: "secrets_vault"
-    };
-  } catch (err) {
-    return {
-      logged_in: false,
-      redirect_url: "",
-      profile_saved: false,
-      method: "not_found",
-      error: err instanceof Error ? err.message : String(err)
-    };
+    const content = csvLines.join(`
+`);
+    writeFileSync3(path, content);
+    return { path, size: content.length };
+  } else {
+    const content = JSON.stringify(dataset.data, null, 2);
+    writeFileSync3(path, content);
+    return { path, size: content.length };
   }
 }
-var init_auth = () => {};
+var init_datasets = __esm(() => {
+  init_schema();
+});
 
 // ../open-mementos/dist/index.js
 var exports_dist = {};
@@ -17192,10 +17929,10 @@ __export(exports_dist, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG
 });
 import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync6, mkdirSync as mkdirSync9 } from "fs";
-import { dirname, join as join10, resolve } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
-import { homedir as homedir10 } from "os";
+import { existsSync as existsSync7, mkdirSync as mkdirSync10 } from "fs";
+import { dirname, join as join12, resolve } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync5, readdirSync as readdirSync4, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir12 } from "os";
 import { basename as basename2, dirname as dirname2, join as join22, resolve as resolve2 } from "path";
 import { existsSync as existsSync32, mkdirSync as mkdirSync32, readFileSync as readFileSync22, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir22 } from "os";
@@ -17209,8 +17946,8 @@ function isInMemoryDb(path) {
 function findNearestMementosDb(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    const candidate = join10(dir, ".mementos", "mementos.db");
-    if (existsSync6(candidate))
+    const candidate = join12(dir, ".mementos", "mementos.db");
+    if (existsSync7(candidate))
       return candidate;
     const parent = dirname(dir);
     if (parent === dir)
@@ -17222,7 +17959,7 @@ function findNearestMementosDb(startDir) {
 function findGitRoot(startDir) {
   let dir = resolve(startDir);
   while (true) {
-    if (existsSync6(join10(dir, ".git")))
+    if (existsSync7(join12(dir, ".git")))
       return dir;
     const parent = dirname(dir);
     if (parent === dir)
@@ -17242,18 +17979,18 @@ function getDbPath() {
   if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot(cwd);
     if (gitRoot) {
-      return join10(gitRoot, ".mementos", "mementos.db");
+      return join12(gitRoot, ".mementos", "mementos.db");
     }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join10(home, ".mementos", "mementos.db");
+  return join12(home, ".mementos", "mementos.db");
 }
 function ensureDir2(filePath) {
   if (isInMemoryDb(filePath))
     return;
   const dir = dirname(resolve(filePath));
-  if (!existsSync6(dir)) {
-    mkdirSync9(dir, { recursive: true });
+  if (!existsSync7(dir)) {
+    mkdirSync10(dir, { recursive: true });
   }
 }
 function getDatabase2(dbPath) {
@@ -19103,11 +19840,11 @@ function isValidCategory(value) {
   return VALID_CATEGORIES.includes(value);
 }
 function loadConfig() {
-  const configPath = join22(homedir10(), ".mementos", "config.json");
+  const configPath = join22(homedir12(), ".mementos", "config.json");
   let fileConfig = {};
   if (existsSync22(configPath)) {
     try {
-      const raw = readFileSync4(configPath, "utf-8");
+      const raw = readFileSync5(configPath, "utf-8");
       fileConfig = JSON.parse(raw);
     } catch {}
   }
@@ -19130,17 +19867,17 @@ function loadConfig() {
   return merged;
 }
 function profilesDir() {
-  return join22(homedir10(), ".mementos", "profiles");
+  return join22(homedir12(), ".mementos", "profiles");
 }
 function globalConfigPath() {
-  return join22(homedir10(), ".mementos", "config.json");
+  return join22(homedir12(), ".mementos", "config.json");
 }
 function readGlobalConfig() {
   const p = globalConfigPath();
   if (!existsSync22(p))
     return {};
   try {
-    return JSON.parse(readFileSync4(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return {};
   }
@@ -19148,7 +19885,7 @@ function readGlobalConfig() {
 function writeGlobalConfig(data) {
   const p = globalConfigPath();
   ensureDir22(dirname2(p));
-  writeFileSync3(p, JSON.stringify(data, null, 2), "utf-8");
+  writeFileSync4(p, JSON.stringify(data, null, 2), "utf-8");
 }
 function getActiveProfile() {
   const envProfile = process.env["MEMENTOS_PROFILE"];
@@ -21813,30 +22550,30 @@ __export(exports_dist2, {
   acquireLock: () => acquireLock2
 });
 import { Database as Database3 } from "bun:sqlite";
-import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
-import { homedir as homedir11 } from "os";
-import { randomUUID as randomUUID11 } from "crypto";
+import { mkdirSync as mkdirSync11 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
+import { homedir as homedir13 } from "os";
+import { randomUUID as randomUUID14 } from "crypto";
 import { mkdirSync as mkdirSync23, copyFileSync as copyFileSync3, statSync as statSync2 } from "fs";
 import { join as join33 } from "path";
 import { homedir as homedir33 } from "os";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { join as join23 } from "path";
 import { homedir as homedir23 } from "os";
 import { randomUUID as randomUUID22 } from "crypto";
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync4, mkdirSync as mkdirSync33 } from "fs";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync5, mkdirSync as mkdirSync33 } from "fs";
 import { join as join43, dirname as dirname22 } from "path";
 import { homedir as homedir42 } from "os";
 function getDbPath2() {
   if (process.env.CONVERSATIONS_DB_PATH)
     return process.env.CONVERSATIONS_DB_PATH;
-  return join11(homedir11(), ".conversations", "messages.db");
+  return join13(homedir13(), ".conversations", "messages.db");
 }
 function getDb() {
   if (db)
     return db;
   const dbPath = getDbPath2();
-  mkdirSync10(dirname3(dbPath), { recursive: true });
+  mkdirSync11(dirname3(dbPath), { recursive: true });
   db = new Database3(dbPath, { create: true });
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
@@ -22078,7 +22815,7 @@ function loadConfig2() {
   if (cachedConfig && now2 - configLoadedAt < CONFIG_CACHE_MS)
     return cachedConfig;
   try {
-    const raw = readFileSync5(getConfigPath(), "utf-8");
+    const raw = readFileSync6(getConfigPath(), "utf-8");
     cachedConfig = JSON.parse(raw);
     configLoadedAt = now2;
     return cachedConfig;
@@ -22196,7 +22933,7 @@ function guessMimeType(name) {
 function sendMessage(opts) {
   const db2 = getDb();
   const explicitSession = opts.session_id && opts.session_id.trim().length > 0 ? opts.session_id : undefined;
-  const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID11().slice(0, 8)}`);
+  const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID14().slice(0, 8)}`);
   const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
   const normalizedPriority = opts.priority === "low" || opts.priority === "normal" || opts.priority === "high" || opts.priority === "urgent" ? opts.priority : "normal";
   const blocking = opts.blocking ? 1 : 0;
@@ -23024,7 +23761,7 @@ function getAutoName() {
   cachedAutoName = name;
   try {
     mkdirSync33(dirname22(AGENT_ID_FILE), { recursive: true });
-    writeFileSync4(AGENT_ID_FILE, name + `
+    writeFileSync5(AGENT_ID_FILE, name + `
 `, "utf-8");
   } catch {}
   return name;
@@ -24979,7 +25716,7 @@ Your code should look like:
             }
           }
         }
-        function checkPropTypes(typeSpecs, values, location, componentName, element) {
+        function checkPropTypes(typeSpecs, values, location2, componentName, element) {
           {
             var has = Function.call.bind(hasOwnProperty);
             for (var typeSpecName in typeSpecs) {
@@ -24987,23 +25724,23 @@ Your code should look like:
                 var error$1 = undefined;
                 try {
                   if (typeof typeSpecs[typeSpecName] !== "function") {
-                    var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                    var err = Error((componentName || "React class") + ": " + location2 + " type `" + typeSpecName + "` is invalid; " + "it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`." + "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
                     err.name = "Invariant Violation";
                     throw err;
                   }
-                  error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+                  error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location2, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
                 } catch (ex) {
                   error$1 = ex;
                 }
                 if (error$1 && !(error$1 instanceof Error)) {
                   setCurrentlyValidatingElement(element);
-                  error("%s: type specification of %s" + " `%s` is invalid; the type checker " + "function must return `null` or an `Error` but returned a %s. " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
+                  error("%s: type specification of %s" + " `%s` is invalid; the type checker " + "function must return `null` or an `Error` but returned a %s. " + "You may have forgotten to pass an argument to the type checker " + "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " + "shape all require an argument).", componentName || "React class", location2, typeSpecName, typeof error$1);
                   setCurrentlyValidatingElement(null);
                 }
                 if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
                   loggedTypeFailures[error$1.message] = true;
                   setCurrentlyValidatingElement(element);
-                  error("Failed %s type: %s", location, error$1.message);
+                  error("Failed %s type: %s", location2, error$1.message);
                   setCurrentlyValidatingElement(null);
                 }
               }
@@ -26238,11 +26975,11 @@ __export(exports_dist3, {
   AgentNotFoundError: () => AgentNotFoundError2
 });
 import { Database as Database4 } from "bun:sqlite";
-import { existsSync as existsSync7, mkdirSync as mkdirSync11 } from "fs";
-import { dirname as dirname5, join as join12, resolve as resolve3 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync12 } from "fs";
+import { dirname as dirname5, join as join14, resolve as resolve3 } from "path";
 import { existsSync as existsSync33 } from "fs";
 import { join as join34 } from "path";
-import { existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
 import { join as join24 } from "path";
 import { existsSync as existsSync43, readFileSync as readFileSync24, readdirSync as readdirSync22, writeFileSync as writeFileSync23 } from "fs";
 import { join as join44 } from "path";
@@ -26472,8 +27209,8 @@ function isInMemoryDb2(path) {
 function findNearestTodosDb(startDir) {
   let dir = resolve3(startDir);
   while (true) {
-    const candidate = join12(dir, ".todos", "todos.db");
-    if (existsSync7(candidate))
+    const candidate = join14(dir, ".todos", "todos.db");
+    if (existsSync8(candidate))
       return candidate;
     const parent = dirname5(dir);
     if (parent === dir)
@@ -26485,7 +27222,7 @@ function findNearestTodosDb(startDir) {
 function findGitRoot2(startDir) {
   let dir = resolve3(startDir);
   while (true) {
-    if (existsSync7(join12(dir, ".git")))
+    if (existsSync8(join14(dir, ".git")))
       return dir;
     const parent = dirname5(dir);
     if (parent === dir)
@@ -26505,18 +27242,18 @@ function getDbPath3() {
   if (process.env["TODOS_DB_SCOPE"] === "project") {
     const gitRoot = findGitRoot2(cwd);
     if (gitRoot) {
-      return join12(gitRoot, ".todos", "todos.db");
+      return join14(gitRoot, ".todos", "todos.db");
     }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  return join12(home, ".todos", "todos.db");
+  return join14(home, ".todos", "todos.db");
 }
 function ensureDir3(filePath) {
   if (isInMemoryDb2(filePath))
     return;
   const dir = dirname5(resolve3(filePath));
-  if (!existsSync7(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  if (!existsSync8(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
 }
 function getDatabase3(dbPath) {
@@ -26986,24 +27723,24 @@ function listJsonFiles(dir) {
 }
 function readJsonFile(path) {
   try {
-    return JSON.parse(readFileSync6(path, "utf-8"));
+    return JSON.parse(readFileSync7(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(path, data) {
-  writeFileSync5(path, JSON.stringify(data, null, 2) + `
+  writeFileSync6(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readHighWaterMark(dir) {
   const path = join24(dir, ".highwatermark");
   if (!existsSync23(path))
     return 1;
-  const val = parseInt(readFileSync6(path, "utf-8").trim(), 10);
+  const val = parseInt(readFileSync7(path, "utf-8").trim(), 10);
   return isNaN(val) ? 1 : val;
 }
 function writeHighWaterMark(dir, value) {
-  writeFileSync5(join24(dir, ".highwatermark"), String(value));
+  writeFileSync6(join24(dir, ".highwatermark"), String(value));
 }
 function getFileMtimeMs(path) {
   try {
@@ -31593,9 +32330,9 @@ __export(exports_dist4, {
   CATEGORIES: () => CATEGORIES,
   AGENT_TARGETS: () => AGENT_TARGETS
 });
-import { existsSync as existsSync8, cpSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync6, rmSync as rmSync2, readdirSync as readdirSync6, statSync as statSync4, readFileSync as readFileSync7, accessSync, constants } from "fs";
-import { join as join13, dirname as dirname6 } from "path";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync9, cpSync, mkdirSync as mkdirSync13, writeFileSync as writeFileSync7, rmSync as rmSync2, readdirSync as readdirSync6, statSync as statSync4, readFileSync as readFileSync8, accessSync, constants } from "fs";
+import { join as join15, dirname as dirname6 } from "path";
+import { homedir as homedir14 } from "os";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync24, readFileSync as readFileSync25, readdirSync as readdirSync23 } from "fs";
 import { join as join25 } from "path";
@@ -31706,35 +32443,35 @@ function normalizeSkillName(name) {
 function findSkillsDir() {
   let dir = __dirname2;
   for (let i = 0;i < 5; i++) {
-    const candidate = join13(dir, "skills");
-    if (existsSync8(candidate)) {
+    const candidate = join15(dir, "skills");
+    if (existsSync9(candidate)) {
       return candidate;
     }
     dir = dirname6(dir);
   }
-  return join13(__dirname2, "..", "skills");
+  return join15(__dirname2, "..", "skills");
 }
 function getSkillPath(name) {
   const skillName = normalizeSkillName(name);
-  return join13(SKILLS_DIR, skillName);
+  return join15(SKILLS_DIR, skillName);
 }
 function skillExists(name) {
-  return existsSync8(getSkillPath(name));
+  return existsSync9(getSkillPath(name));
 }
 function installSkill(name, options = {}) {
   const { targetDir = process.cwd(), overwrite = false } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  const destDir = join13(targetDir, ".skills");
-  const destPath = join13(destDir, skillName);
-  if (!existsSync8(sourcePath)) {
+  const destDir = join15(targetDir, ".skills");
+  const destPath = join15(destDir, skillName);
+  if (!existsSync9(sourcePath)) {
     return {
       skill: name,
       success: false,
       error: `Skill '${name}' not found`
     };
   }
-  if (existsSync8(destPath) && !overwrite) {
+  if (existsSync9(destPath) && !overwrite) {
     return {
       skill: name,
       success: false,
@@ -31743,10 +32480,10 @@ function installSkill(name, options = {}) {
     };
   }
   try {
-    if (!existsSync8(destDir)) {
-      mkdirSync12(destDir, { recursive: true });
+    if (!existsSync9(destDir)) {
+      mkdirSync13(destDir, { recursive: true });
     }
-    if (existsSync8(destPath) && overwrite) {
+    if (existsSync9(destPath) && overwrite) {
       rmSync2(destPath, { recursive: true, force: true });
     }
     cpSync(sourcePath, destPath, {
@@ -31785,7 +32522,7 @@ function installSkills(names, options = {}) {
   return names.map((name) => installSkill(name, options));
 }
 function updateSkillsIndex(skillsDir) {
-  const indexPath = join13(skillsDir, "index.ts");
+  const indexPath = join15(skillsDir, "index.ts");
   const meta = loadMeta(skillsDir);
   const disabledSet = new Set(meta.disabled || []);
   const skills = readdirSync6(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
@@ -31801,31 +32538,31 @@ function updateSkillsIndex(skillsDir) {
 
 ${exports}
 `;
-  writeFileSync6(indexPath, content);
+  writeFileSync7(indexPath, content);
 }
 function getMetaPath(skillsDir) {
-  return join13(skillsDir, ".meta.json");
+  return join15(skillsDir, ".meta.json");
 }
 function loadMeta(skillsDir) {
   const metaPath2 = getMetaPath(skillsDir);
-  if (existsSync8(metaPath2)) {
+  if (existsSync9(metaPath2)) {
     try {
-      return JSON.parse(readFileSync7(metaPath2, "utf-8"));
+      return JSON.parse(readFileSync8(metaPath2, "utf-8"));
     } catch {}
   }
   return { skills: {} };
 }
 function saveMeta(skillsDir, meta) {
-  writeFileSync6(getMetaPath(skillsDir), JSON.stringify(meta, null, 2));
+  writeFileSync7(getMetaPath(skillsDir), JSON.stringify(meta, null, 2));
 }
 function recordInstall(skillsDir, name) {
   const meta = loadMeta(skillsDir);
   const skillName = normalizeSkillName(name);
   let version = "unknown";
   try {
-    const pkgPath = join13(skillsDir, skillName, "package.json");
-    if (existsSync8(pkgPath)) {
-      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    const pkgPath = join15(skillsDir, skillName, "package.json");
+    if (existsSync9(pkgPath)) {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
       version = pkg.version || "unknown";
     }
   } catch {}
@@ -31838,12 +32575,12 @@ function recordRemove(skillsDir, name) {
   saveMeta(skillsDir, meta);
 }
 function getInstallMeta(targetDir = process.cwd()) {
-  return loadMeta(join13(targetDir, ".skills"));
+  return loadMeta(join15(targetDir, ".skills"));
 }
 function disableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join13(targetDir, ".skills");
+  const skillsDir = join15(targetDir, ".skills");
   const skillName = normalizeSkillName(name);
-  if (!existsSync8(join13(skillsDir, skillName)))
+  if (!existsSync9(join15(skillsDir, skillName)))
     return false;
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
@@ -31856,7 +32593,7 @@ function disableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function enableSkill(name, targetDir = process.cwd()) {
-  const skillsDir = join13(targetDir, ".skills");
+  const skillsDir = join15(targetDir, ".skills");
   const meta = loadMeta(skillsDir);
   const disabled = new Set(meta.disabled || []);
   if (!disabled.has(name))
@@ -31868,24 +32605,24 @@ function enableSkill(name, targetDir = process.cwd()) {
   return true;
 }
 function getDisabledSkills(targetDir = process.cwd()) {
-  const meta = loadMeta(join13(targetDir, ".skills"));
+  const meta = loadMeta(join15(targetDir, ".skills"));
   return meta.disabled || [];
 }
 function getInstalledSkills(targetDir = process.cwd()) {
-  const skillsDir = join13(targetDir, ".skills");
-  if (!existsSync8(skillsDir)) {
+  const skillsDir = join15(targetDir, ".skills");
+  if (!existsSync9(skillsDir)) {
     return [];
   }
   return readdirSync6(skillsDir).filter((f) => {
-    const fullPath = join13(skillsDir, f);
+    const fullPath = join15(skillsDir, f);
     return f.startsWith("skill-") && statSync4(fullPath).isDirectory();
   }).map((f) => f.replace("skill-", ""));
 }
 function removeSkill(name, targetDir = process.cwd()) {
   const skillName = normalizeSkillName(name);
-  const skillsDir = join13(targetDir, ".skills");
-  const skillPath = join13(skillsDir, skillName);
-  if (!existsSync8(skillPath)) {
+  const skillsDir = join15(targetDir, ".skills");
+  const skillPath = join15(skillsDir, skillName);
+  if (!existsSync9(skillPath)) {
     return false;
   }
   rmSync2(skillPath, { recursive: true, force: true });
@@ -31896,25 +32633,25 @@ function removeSkill(name, targetDir = process.cwd()) {
 function getAgentSkillsDir(agent, scope = "global", projectDir) {
   const agentDir = `.${agent}`;
   if (scope === "project") {
-    return join13(projectDir || process.cwd(), agentDir, "skills");
+    return join15(projectDir || process.cwd(), agentDir, "skills");
   }
-  return join13(homedir12(), agentDir, "skills");
+  return join15(homedir14(), agentDir, "skills");
 }
 function getAgentSkillPath(name, agent, scope = "global", projectDir) {
   const skillName = normalizeSkillName(name);
-  return join13(getAgentSkillsDir(agent, scope, projectDir), skillName);
+  return join15(getAgentSkillsDir(agent, scope, projectDir), skillName);
 }
 function installSkillForAgent(name, options, generateSkillMd) {
   const { agent, scope = "global", projectDir } = options;
   const skillName = normalizeSkillName(name);
   const sourcePath = getSkillPath(name);
-  if (!existsSync8(sourcePath)) {
+  if (!existsSync9(sourcePath)) {
     return { skill: name, success: false, error: `Skill '${name}' not found` };
   }
   let skillMdContent = null;
-  const skillMdPath = join13(sourcePath, "SKILL.md");
-  if (existsSync8(skillMdPath)) {
-    skillMdContent = readFileSync7(skillMdPath, "utf-8");
+  const skillMdPath = join15(sourcePath, "SKILL.md");
+  if (existsSync9(skillMdPath)) {
+    skillMdContent = readFileSync8(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMdContent = generateSkillMd(name);
   }
@@ -31923,8 +32660,8 @@ function installSkillForAgent(name, options, generateSkillMd) {
   }
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
   if (scope === "global") {
-    const agentBaseDir2 = join13(homedir12(), `.${agent}`);
-    if (!existsSync8(agentBaseDir2)) {
+    const agentBaseDir2 = join15(homedir14(), `.${agent}`);
+    if (!existsSync9(agentBaseDir2)) {
       const agentLabels = {
         claude: "Claude Code",
         codex: "Codex CLI",
@@ -31947,8 +32684,8 @@ function installSkillForAgent(name, options, generateSkillMd) {
     }
   }
   try {
-    mkdirSync12(destDir, { recursive: true });
-    writeFileSync6(join13(destDir, "SKILL.md"), skillMdContent);
+    mkdirSync13(destDir, { recursive: true });
+    writeFileSync7(join15(destDir, "SKILL.md"), skillMdContent);
     return { skill: name, success: true, path: destDir };
   } catch (error) {
     return {
@@ -31961,7 +32698,7 @@ function installSkillForAgent(name, options, generateSkillMd) {
 function removeSkillForAgent(name, options) {
   const { agent, scope = "global", projectDir } = options;
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
-  if (!existsSync8(destDir)) {
+  if (!existsSync9(destDir)) {
     return false;
   }
   rmSync2(destDir, { recursive: true, force: true });
@@ -33885,7 +34622,7 @@ __export(exports_cron_manager, {
   deleteCronJob: () => deleteCronJob,
   createCronJob: () => createCronJob
 });
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 function ensureCronTable() {
   const db2 = getDatabase();
   db2.exec(`
@@ -33914,7 +34651,7 @@ function ensureCronTable() {
 function createCronJob(schedule, task, name) {
   ensureCronTable();
   const db2 = getDatabase();
-  const id = randomUUID12();
+  const id = randomUUID15();
   db2.prepare(`
     INSERT INTO cron_jobs (id, name, schedule, task_json, enabled)
     VALUES (?, ?, ?, ?, 1)
@@ -33972,7 +34709,7 @@ function getCronEvents(jobId, limit = 10) {
 async function executeCronJob(job) {
   ensureCronTable();
   const db2 = getDatabase();
-  const eventId = randomUUID12();
+  const eventId = randomUUID15();
   const startedAt = new Date().toISOString();
   db2.prepare("INSERT INTO cron_events (id, job_id, started_at) VALUES (?, ?, ?)").run(eventId, job.id, startedAt);
   try {
@@ -34063,7 +34800,7 @@ __export(exports_url_watcher, {
   deleteWatchJob: () => deleteWatchJob,
   createWatchJob: () => createWatchJob
 });
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 import { createHash } from "crypto";
 function ensureWatchTables() {
   const db2 = getDatabase();
@@ -34095,7 +34832,7 @@ function ensureWatchTables() {
 function createWatchJob(url, schedule, opts) {
   ensureWatchTables();
   const db2 = getDatabase();
-  const id = randomUUID13();
+  const id = randomUUID16();
   db2.prepare(`
     INSERT INTO watch_jobs (id, name, url, schedule, selector, extract_schema, enabled)
     VALUES (?, ?, ?, ?, ?, ?, 1)
@@ -34131,7 +34868,7 @@ function getWatchEvents(watchId, limit = 20) {
 async function checkWatchJob(job) {
   ensureWatchTables();
   const db2 = getDatabase();
-  const eventId = randomUUID13();
+  const eventId = randomUUID16();
   const checkedAt = new Date().toISOString();
   let newContent = "";
   try {
@@ -34306,8 +35043,8 @@ var init_ai_task = () => {};
 var exports_mcp = {};
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { readFileSync as readFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join16 } from "path";
 function json(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
@@ -34372,7 +35109,7 @@ var init_mcp = __esm(async () => {
   init_dialogs();
   init_profiles();
   init_types();
-  _pkg = JSON.parse(readFileSync8(join14(import.meta.dir, "../../package.json"), "utf8"));
+  _pkg = JSON.parse(readFileSync9(join16(import.meta.dir, "../../package.json"), "utf8"));
   networkLogCleanup = new Map;
   consoleCaptureCleanup = new Map;
   harCaptures = new Map;
@@ -34451,6 +35188,25 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_session_fork", "Fork a session: create a new session with the same auth state (cookies, storage) and URL as an existing one. Like git branch for browser sessions.", { source_session_id: exports_external.string(), name: exports_external.string().optional() }, async ({ source_session_id, name }) => {
+    try {
+      const sourcePage = getSessionPage(source_session_id);
+      const sourceUrl = sourcePage.url();
+      const tempName = `_fork_${Date.now()}`;
+      const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      await saveStateFromPage2(sourcePage, tempName);
+      const { session, page } = await createSession2({
+        storageState: tempName,
+        startUrl: sourceUrl,
+        name: name ?? `fork-of-${source_session_id.slice(0, 8)}`
+      });
+      const { deleteState: deleteState2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      deleteState2(tempName);
+      return json({ forked_session: session, source_url: sourceUrl });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_session_timeline", "Get chronological action log for a session", { session_id: exports_external.string().optional(), limit: exports_external.number().optional().default(50) }, async ({ session_id, limit }) => {
     try {
       const sid = resolveSessionId(session_id);
@@ -35044,6 +35800,52 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_intercept_response", "Intercept and modify API responses for testing. Mock data, simulate errors, add latency.", {
+    session_id: exports_external.string().optional(),
+    url_pattern: exports_external.string().describe("URL pattern to intercept (e.g. '**/api/users*')"),
+    action: exports_external.enum(["mock", "delay", "error"]).describe("What to do with matched requests"),
+    mock_body: exports_external.string().optional().describe("Response body for mock action"),
+    mock_content_type: exports_external.string().optional().default("application/json"),
+    status_code: exports_external.number().optional().default(200).describe("HTTP status code (for mock/error)"),
+    delay_ms: exports_external.number().optional().default(3000).describe("Delay in ms (for delay action)")
+  }, async ({ session_id, url_pattern, action, mock_body, mock_content_type, status_code, delay_ms }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      await page.route(url_pattern, async (route) => {
+        if (action === "mock") {
+          await route.fulfill({
+            status: status_code,
+            contentType: mock_content_type,
+            body: mock_body ?? "{}"
+          });
+        } else if (action === "error") {
+          await route.fulfill({
+            status: status_code ?? 500,
+            contentType: "application/json",
+            body: JSON.stringify({ error: "Intercepted error", status: status_code })
+          });
+        } else if (action === "delay") {
+          await new Promise((r) => setTimeout(r, delay_ms));
+          await route.continue();
+        }
+      });
+      logEvent(sid, "intercept_set", { url_pattern, action, status_code });
+      return json({ intercepted: true, url_pattern, action });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_intercept_clear", "Remove all response intercepts from a session", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      await page.unrouteAll({ behavior: "ignoreErrors" });
+      return json({ cleared: true });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_performance", "Get performance metrics for the current page", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
     try {
       const sid = resolveSessionId(session_id);
@@ -35054,6 +35856,72 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_detect_env", "Detect if the current page is running in production, development, staging, or local environment. Analyzes URL, meta tags, source maps, analytics SDKs, and more.", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { detectEnvironment: detectEnvironment2 } = await Promise.resolve().then(() => exports_env_detector);
+      const result = await detectEnvironment2(page);
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_performance_deep", "Deep performance analysis: Web Vitals, resource breakdown by type, largest resources, third-party scripts with categories, DOM complexity, memory usage.", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { getDeepPerformance: getDeepPerformance2 } = await Promise.resolve().then(() => (init_deep_performance(), exports_deep_performance));
+      const result = await getDeepPerformance2(page);
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_accessibility_audit", "Run accessibility audit on the page. Injects axe-core and returns violations grouped by severity (critical, serious, moderate, minor).", { session_id: exports_external.string().optional(), selector: exports_external.string().optional().describe("Scope audit to a specific element") }, async ({ session_id, selector }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      await page.evaluate(`
+        if (!window.axe) {
+          const script = document.createElement('script');
+          script.src = 'https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.10.2/axe.min.js';
+          document.head.appendChild(script);
+          await new Promise((resolve, reject) => {
+            script.onload = resolve;
+            script.onerror = reject;
+          });
+        }
+      `);
+      await new Promise((r) => setTimeout(r, 500));
+      const results = await page.evaluate((sel) => {
+        const opts = {};
+        if (sel)
+          opts.include = [sel];
+        return window.axe.run(opts.include ? { include: [sel] } : document).then((r) => ({
+          violations: r.violations.map((v) => ({
+            id: v.id,
+            impact: v.impact,
+            description: v.description,
+            help: v.help,
+            helpUrl: v.helpUrl,
+            nodes_count: v.nodes.length,
+            selectors: v.nodes.slice(0, 3).map((n) => n.target?.[0] ?? "")
+          })),
+          passes: r.passes.length,
+          violations_count: r.violations.length,
+          incomplete: r.incomplete.length
+        }));
+      }, selector);
+      const byImpact = { critical: 0, serious: 0, moderate: 0, minor: 0 };
+      for (const v of results.violations) {
+        byImpact[v.impact] = (byImpact[v.impact] || 0) + 1;
+      }
+      return json({ ...results, by_impact: byImpact, score: Math.max(0, 100 - results.violations_count * 5) });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_console_log", "Get captured console messages for a session", { session_id: exports_external.string().optional(), level: exports_external.enum(["log", "warn", "error", "debug", "info"]).optional() }, async ({ session_id, level }) => {
     try {
       const sid = resolveSessionId(session_id);
@@ -35117,6 +35985,46 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_workflow_save", "Save a recording as a reusable workflow with self-healing replay", { recording_id: exports_external.string(), name: exports_external.string(), description: exports_external.string().optional() }, async ({ recording_id, name, description }) => {
+    try {
+      const { saveWorkflowFromRecording: saveWorkflowFromRecording2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+      return json(saveWorkflowFromRecording2(recording_id, name, description));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_workflow_list", "List all saved workflows", {}, async () => {
+    try {
+      const { listWorkflows: listWorkflows2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+      const workflows = listWorkflows2();
+      return json({ workflows: workflows.map((w) => ({ ...w, steps: `${w.steps.length} steps` })), count: workflows.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_workflow_run", "Run a saved workflow with self-healing. If selectors changed, auto-adapts and reports what was healed.", { session_id: exports_external.string().optional(), name: exports_external.string() }, async ({ session_id, name }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { getWorkflowByName: getWorkflowByName2, runWorkflow: runWorkflow2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+      const workflow = getWorkflowByName2(name);
+      if (!workflow)
+        return err(new Error(`Workflow '${name}' not found`));
+      const result = await runWorkflow2(workflow, page);
+      logEvent(sid, "workflow_run", { name, ...result });
+      return json(result);
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_workflow_delete", "Delete a saved workflow", { name: exports_external.string() }, async ({ name }) => {
+    try {
+      const { deleteWorkflow: deleteWorkflow2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+      return json({ deleted: deleteWorkflow2(name) });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_crawl", "Crawl a URL recursively and return discovered pages", {
     url: exports_external.string(),
     max_depth: exports_external.number().optional().default(2),
@@ -35415,6 +36323,61 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_wait_for_idle", "Wait until no network requests are in-flight for a specified duration. Essential for SPAs that load data after navigation.", {
+    session_id: exports_external.string().optional(),
+    idle_time: exports_external.number().optional().default(2000).describe("How long (ms) network must be idle to consider page loaded"),
+    timeout: exports_external.number().optional().default(30000).describe("Max wait time (ms) before giving up")
+  }, async ({ session_id, idle_time, timeout }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const t0 = Date.now();
+      let lastActivity = Date.now();
+      let pending = 0;
+      const onRequest = () => {
+        pending++;
+        lastActivity = Date.now();
+      };
+      const onResponse = () => {
+        pending = Math.max(0, pending - 1);
+        if (pending === 0)
+          lastActivity = Date.now();
+      };
+      const onFailed = () => {
+        pending = Math.max(0, pending - 1);
+        if (pending === 0)
+          lastActivity = Date.now();
+      };
+      page.on("request", onRequest);
+      page.on("response", onResponse);
+      page.on("requestfailed", onFailed);
+      try {
+        await new Promise((resolve4, reject) => {
+          const check = () => {
+            const now3 = Date.now();
+            if (now3 - t0 > timeout) {
+              reject(new Error(`Timeout after ${timeout}ms (${pending} requests still pending)`));
+              return;
+            }
+            if (pending === 0 && now3 - lastActivity >= idle_time) {
+              resolve4();
+              return;
+            }
+            setTimeout(check, 100);
+          };
+          check();
+        });
+      } finally {
+        page.removeListener("request", onRequest);
+        page.removeListener("response", onResponse);
+        page.removeListener("requestfailed", onFailed);
+      }
+      const waited_ms = Date.now() - t0;
+      return json({ idle: true, waited_ms, pending_requests: 0 });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_wait_for_text", "Wait until specific text appears on the page", { session_id: exports_external.string().optional(), text: exports_external.string(), timeout: exports_external.number().optional().default(1e4), exact: exports_external.boolean().optional().default(false) }, async ({ session_id, text, timeout, exact }) => {
     try {
       const sid = resolveSessionId(session_id);
@@ -35812,6 +36775,68 @@ var init_mcp = __esm(async () => {
       return err(e);
     }
   });
+  server.tool("browser_detect_apis", "Scan network traffic for JSON API endpoints. Returns discovered endpoints with methods, status codes, and URLs.", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const { detectAPIs: detectAPIs2 } = await Promise.resolve().then(() => (init_api_detector(), exports_api_detector));
+      const apis = detectAPIs2(sid);
+      return json({ apis, count: apis.length });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_extract_structured", "Extract structured data from page: tables, lists, JSON-LD, Open Graph, meta tags, and repeated elements (cards/items).", { session_id: exports_external.string().optional() }, async ({ session_id }) => {
+    try {
+      const sid = resolveSessionId(session_id);
+      const page = getSessionPage(sid);
+      const { extractStructuredData: extractStructuredData2 } = await Promise.resolve().then(() => exports_structured_extract);
+      const data = await extractStructuredData2(page);
+      return json({
+        tables: data.tables.length,
+        lists: data.lists.length,
+        json_ld: data.jsonLd.length,
+        open_graph: Object.keys(data.openGraph).length,
+        meta_tags: Object.keys(data.metaTags).length,
+        repeated_elements: data.repeatedElements.length,
+        data
+      });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_dataset_save", "Save extracted data as a named dataset for later use", { name: exports_external.string(), data: exports_external.array(exports_external.record(exports_external.unknown())), source_url: exports_external.string().optional() }, async ({ name, data, source_url }) => {
+    try {
+      const { saveDataset: saveDataset2 } = await Promise.resolve().then(() => (init_datasets(), exports_datasets));
+      const dataset = saveDataset2({ name, rows: data, sourceUrl: source_url });
+      return json({ id: dataset.id, name: dataset.name, row_count: dataset.row_count });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_dataset_list", "List all saved datasets", {}, async () => {
+    try {
+      const { listDatasets: listDatasets2 } = await Promise.resolve().then(() => (init_datasets(), exports_datasets));
+      return json({ datasets: listDatasets2() });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_dataset_export", "Export a dataset as JSON or CSV file", { name: exports_external.string(), format: exports_external.enum(["json", "csv"]).optional().default("json") }, async ({ name, format }) => {
+    try {
+      const { exportDataset: exportDataset2 } = await Promise.resolve().then(() => (init_datasets(), exports_datasets));
+      return json(exportDataset2(name, format));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("browser_dataset_delete", "Delete a saved dataset", { name: exports_external.string() }, async ({ name }) => {
+    try {
+      const { deleteDataset: deleteDataset2 } = await Promise.resolve().then(() => (init_datasets(), exports_datasets));
+      return json({ deleted: deleteDataset2(name) });
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("browser_help", "Show all available browser tools grouped by category with one-line descriptions", {}, async () => {
     try {
       const groups = {
@@ -35820,7 +36845,8 @@ var init_mcp = __esm(async () => {
           { tool: "browser_back", description: "Navigate back in history" },
           { tool: "browser_forward", description: "Navigate forward in history" },
           { tool: "browser_reload", description: "Reload the current page" },
-          { tool: "browser_wait_for_navigation", description: "Wait for URL change after action" }
+          { tool: "browser_wait_for_navigation", description: "Wait for URL change after action" },
+          { tool: "browser_wait_for_idle", description: "Wait for network idle (no pending requests)" }
         ],
         Interaction: [
           { tool: "browser_click", description: "Click element by ref or selector" },
@@ -35873,7 +36899,9 @@ var init_mcp = __esm(async () => {
           { tool: "browser_network_log", description: "Get captured network requests" },
           { tool: "browser_network_intercept", description: "Add a network interception rule" },
           { tool: "browser_har_start", description: "Start HAR capture" },
-          { tool: "browser_har_stop", description: "Stop HAR capture and get data" }
+          { tool: "browser_har_stop", description: "Stop HAR capture and get data" },
+          { tool: "browser_intercept_response", description: "Mock/delay/error API responses for testing" },
+          { tool: "browser_intercept_clear", description: "Remove all response intercepts" }
         ],
         Performance: [
           { tool: "browser_performance", description: "Get performance metrics" }
@@ -35898,6 +36926,20 @@ var init_mcp = __esm(async () => {
           { tool: "browser_auth_list", description: "List all saved auth flows" },
           { tool: "browser_auth_delete", description: "Delete a saved auth flow" }
         ],
+        Workflows: [
+          { tool: "browser_workflow_save", description: "Save a recording as a reusable workflow" },
+          { tool: "browser_workflow_list", description: "List all saved workflows" },
+          { tool: "browser_workflow_run", description: "Run a workflow with self-healing replay" },
+          { tool: "browser_workflow_delete", description: "Delete a saved workflow" }
+        ],
+        Data: [
+          { tool: "browser_extract_structured", description: "Extract tables, lists, JSON-LD, Open Graph, meta tags, repeated elements" },
+          { tool: "browser_detect_apis", description: "Scan network traffic for JSON API endpoints" },
+          { tool: "browser_dataset_save", description: "Save extracted data as a named dataset" },
+          { tool: "browser_dataset_list", description: "List all saved datasets" },
+          { tool: "browser_dataset_export", description: "Export dataset as JSON or CSV" },
+          { tool: "browser_dataset_delete", description: "Delete a saved dataset" }
+        ],
         Crawl: [
           { tool: "browser_crawl", description: "Crawl a URL recursively" }
         ],
@@ -35942,6 +36984,7 @@ var init_mcp = __esm(async () => {
           { tool: "browser_session_untag", description: "Remove a tag from a session" },
           { tool: "browser_session_stats", description: "Get session stats and token usage" },
           { tool: "browser_session_timeline", description: "Get chronological action log" },
+          { tool: "browser_session_fork", description: "Fork a session (same auth state + URL)" },
           { tool: "browser_tab_new", description: "Open a new tab" },
           { tool: "browser_tab_list", description: "List all open tabs" },
           { tool: "browser_tab_switch", description: "Switch to a tab by index" },
@@ -35951,6 +36994,9 @@ var init_mcp = __esm(async () => {
           { tool: "browser_check", description: "RECOMMENDED: One-call page summary with diagnostics" },
           { tool: "browser_version", description: "Show running binary version and tool count" },
           { tool: "browser_help", description: "Show this help (all tools)" },
+          { tool: "browser_detect_env", description: "Detect environment (prod/dev/staging/local)" },
+          { tool: "browser_performance_deep", description: "Deep performance: resources, third-party, DOM, memory" },
+          { tool: "browser_accessibility_audit", description: "Run axe-core accessibility audit with severity breakdown" },
           { tool: "browser_snapshot_diff", description: "Diff current snapshot vs previous" },
           { tool: "browser_watch_start", description: "Watch page for DOM changes" },
           { tool: "browser_watch_get_changes", description: "Get captured DOM changes" },
@@ -36468,10 +37514,10 @@ __export(exports_snapshots, {
   deleteSnapshot: () => deleteSnapshot,
   createSnapshot: () => createSnapshot
 });
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 function createSnapshot(data) {
   const db2 = getDatabase();
-  const id = randomUUID14();
+  const id = randomUUID17();
   db2.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);
 }
@@ -36497,8 +37543,8 @@ var init_snapshots = __esm(() => {
 
 // src/server/index.ts
 var exports_server = {};
-import { join as join15 } from "path";
-import { existsSync as existsSync9 } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync10 } from "fs";
 function ok(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
@@ -36524,7 +37570,7 @@ function serverError(e) {
     headers: { "Content-Type": "application/json", ...CORS_HEADERS }
   });
 }
-var PORT, CORS_HEADERS, networkCleanup, consoleCleanup, harCaptures2, server2;
+var PORT, startTime, CORS_HEADERS, networkCleanup, consoleCleanup, harCaptures2, server2;
 var init_server = __esm(() => {
   init_session();
   init_actions();
@@ -36543,6 +37589,7 @@ var init_server = __esm(() => {
   init_downloads();
   init_gallery_diff();
   PORT = parseInt(process.env["BROWSER_SERVER_PORT"] ?? "7030");
+  startTime = Date.now();
   CORS_HEADERS = {
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
@@ -36561,6 +37608,14 @@ var init_server = __esm(() => {
         return new Response(null, { status: 204, headers: CORS_HEADERS });
       }
       try {
+        if (path === "/health" && method === "GET") {
+          const activeSessions = listSessions2({ status: "active" });
+          return ok({
+            status: "ok",
+            active_sessions: activeSessions.length,
+            uptime_ms: Date.now() - startTime
+          });
+        }
         if (path === "/api/sessions" && method === "GET") {
           const status = url.searchParams.get("status");
           const projectId = url.searchParams.get("project_id") ?? undefined;
@@ -36748,14 +37803,14 @@ var init_server = __esm(() => {
         if (path.match(/^\/api\/gallery\/([^/]+)\/thumbnail$/) && method === "GET") {
           const id = path.split("/")[3];
           const entry = getEntry(id);
-          if (!entry?.thumbnail_path || !existsSync9(entry.thumbnail_path))
+          if (!entry?.thumbnail_path || !existsSync10(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 || !existsSync9(entry.path))
+          if (!entry?.path || !existsSync10(entry.path))
             return notFound("Image not found");
           return new Response(Bun.file(entry.path), { headers: { ...CORS_HEADERS } });
         }
@@ -36783,7 +37838,7 @@ var init_server = __esm(() => {
         if (path.match(/^\/api\/downloads\/([^/]+)\/raw$/) && method === "GET") {
           const id = path.split("/")[3];
           const file = getDownload(id);
-          if (!file || !existsSync9(file.path))
+          if (!file || !existsSync10(file.path))
             return notFound("Download not found");
           return new Response(Bun.file(file.path), { headers: { ...CORS_HEADERS } });
         }
@@ -36791,13 +37846,13 @@ var init_server = __esm(() => {
           const id = path.split("/")[3];
           return ok({ deleted: deleteDownload(id) });
         }
-        const dashboardDist = join15(import.meta.dir, "../../dashboard/dist");
-        if (existsSync9(dashboardDist)) {
-          const filePath = path === "/" ? join15(dashboardDist, "index.html") : join15(dashboardDist, path);
-          if (existsSync9(filePath)) {
+        const dashboardDist = join17(import.meta.dir, "../../dashboard/dist");
+        if (existsSync10(dashboardDist)) {
+          const filePath = path === "/" ? join17(dashboardDist, "index.html") : join17(dashboardDist, path);
+          if (existsSync10(filePath)) {
             return new Response(Bun.file(filePath), { headers: CORS_HEADERS });
           }
-          return new Response(Bun.file(join15(dashboardDist, "index.html")), { headers: CORS_HEADERS });
+          return new Response(Bun.file(join17(dashboardDist, "index.html")), { headers: CORS_HEADERS });
         }
         if (path === "/" || path === "") {
           return new Response("@hasna/browser REST API running. Dashboard not built.", {
@@ -36839,10 +37894,10 @@ init_projects();
 init_recorder();
 init_recordings();
 init_lightpanda();
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join18 } from "path";
 import chalk from "chalk";
-var pkg = JSON.parse(readFileSync9(join16(import.meta.dir, "../../package.json"), "utf8"));
+var pkg = JSON.parse(readFileSync10(join18(import.meta.dir, "../../package.json"), "utf8"));
 var program2 = new Command;
 program2.name("browser").description("@hasna/browser \u2014 general-purpose browser agent CLI").version(pkg.version);
 program2.command("navigate <url>").description("Navigate to a URL and optionally take a screenshot").option("--engine <engine>", "Browser engine: playwright|cdp|lightpanda|auto", "auto").option("--screenshot", "Take a screenshot after navigation").option("--extract", "Extract page text after navigation").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
@@ -36903,6 +37958,148 @@ program2.command("check <url>").description("One-liner page health check: naviga
   }
   await closeSession2(session.id);
 });
+program2.command("audit <url>").description("Full site audit: env detection, performance, errors, APIs, data extraction, screenshot").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const t0 = Date.now();
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed, captureNetwork: true, captureConsole: true });
+  if (!opts.json)
+    console.log(chalk.gray(`Auditing: ${url}
+`));
+  await navigate(page, url);
+  await new Promise((r) => setTimeout(r, 2000));
+  const title = await page.title();
+  const currentUrl = page.url();
+  let env = {};
+  try {
+    const { detectEnvironment: detectEnvironment2 } = await Promise.resolve().then(() => exports_env_detector);
+    env = await detectEnvironment2(page);
+  } catch {}
+  let perf = {};
+  try {
+    const { getDeepPerformance: getDeepPerformance2 } = await Promise.resolve().then(() => (init_deep_performance(), exports_deep_performance));
+    perf = await getDeepPerformance2(page);
+  } catch {}
+  const { getConsoleLog: getConsoleLog2 } = await Promise.resolve().then(() => (init_console_log(), exports_console_log));
+  const errors2 = getConsoleLog2(session.id, "error");
+  let apis = [];
+  try {
+    const { detectAPIs: detectAPIs2 } = await Promise.resolve().then(() => (init_api_detector(), exports_api_detector));
+    apis = detectAPIs2(session.id);
+  } catch {}
+  let structured = {};
+  try {
+    const { extractStructuredData: extractStructuredData2 } = await Promise.resolve().then(() => exports_structured_extract);
+    structured = await extractStructuredData2(page);
+  } catch {}
+  const screenshot = await takeScreenshot(page, { maxWidth: 1280, quality: 75 });
+  const duration = Date.now() - t0;
+  const report = {
+    url: currentUrl,
+    title,
+    duration_ms: duration,
+    environment: env,
+    performance: {
+      fcp_ms: perf.web_vitals?.fcp,
+      ttfb_ms: perf.web_vitals?.ttfb,
+      total_resources: perf.resources?.total_resources,
+      total_transfer_kb: perf.resources ? +(perf.resources.total_transfer_bytes / 1024).toFixed(1) : 0,
+      resource_breakdown: perf.resources?.by_type,
+      third_party_count: perf.third_party?.length ?? 0,
+      third_party: perf.third_party,
+      dom_nodes: perf.dom?.node_count,
+      dom_max_depth: perf.dom?.max_depth,
+      memory_mb: perf.memory?.js_heap_used_mb
+    },
+    errors: { count: errors2.length, sample: errors2.slice(0, 3).map((e) => e.message?.slice(0, 100)) },
+    apis: { count: apis.length, endpoints: apis.map((a) => `${a.method} ${a.url}`) },
+    data: {
+      tables: structured.tables?.length ?? 0,
+      lists: structured.lists?.length ?? 0,
+      json_ld: structured.jsonLd?.length ?? 0,
+      open_graph: Object.keys(structured.openGraph ?? {}).length,
+      repeated_elements: structured.repeatedElements?.length ?? 0
+    },
+    screenshot: screenshot.path
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(chalk.bold(`${title}`));
+    console.log(chalk.blue(`  ${currentUrl}
+`));
+    const envColor = env.env === "prod" ? chalk.green : env.env === "staging" ? chalk.yellow : chalk.cyan;
+    console.log(`  Environment: ${envColor(env.env ?? "unknown")} (${env.confidence ?? "?"} confidence)`);
+    console.log(`  Performance: FCP ${perf.web_vitals?.fcp ? perf.web_vitals.fcp + "ms" : "?"}, TTFB ${perf.web_vitals?.ttfb ? Math.round(perf.web_vitals.ttfb) + "ms" : "?"}`);
+    console.log(`  Resources:   ${perf.resources?.total_resources ?? "?"} resources (${report.performance.total_transfer_kb} KB)`);
+    console.log(`  Third-party: ${perf.third_party?.length ?? 0} scripts`);
+    if (perf.third_party?.length > 0) {
+      perf.third_party.slice(0, 5).forEach((tp) => {
+        console.log(chalk.gray(`    ${tp.domain} (${tp.category}, ${(tp.total_bytes / 1024).toFixed(1)}KB)`));
+      });
+    }
+    console.log(`  DOM:         ${perf.dom?.node_count ?? "?"} nodes, depth ${perf.dom?.max_depth ?? "?"}`);
+    console.log(`  Memory:      ${perf.memory?.js_heap_used_mb ?? "?"} MB heap`);
+    const errColor = errors2.length > 0 ? chalk.red : chalk.green;
+    console.log(`  Errors:      ${errColor(errors2.length + " console errors")}`);
+    console.log(`  APIs:        ${apis.length} JSON endpoints detected`);
+    apis.slice(0, 3).forEach((a) => console.log(chalk.gray(`    ${a.method} ${a.url}`)));
+    console.log(`  Data:        ${report.data.tables} tables, ${report.data.lists} lists, ${report.data.json_ld} JSON-LD, ${report.data.repeated_elements} repeated elements`);
+    console.log(`
+  Screenshot:  ${screenshot.path}`);
+    console.log(chalk.gray(`  Completed in ${duration}ms`));
+  }
+  await closeSession2(session.id);
+});
+program2.command("compare <url1> <url2>").description("Compare two URLs: side-by-side screenshots + pixel diff + text diff").option("--engine <engine>", "Browser engine", "auto").option("--json", "Output as JSON").action(async (url1, url2, opts) => {
+  const [s1, s2] = await Promise.all([
+    createSession2({ engine: opts.engine, headless: true }),
+    createSession2({ engine: opts.engine, headless: true })
+  ]);
+  await Promise.all([
+    navigate(s1.page, url1),
+    navigate(s2.page, url2)
+  ]);
+  const [ss1, ss2, text1, text2] = await Promise.all([
+    takeScreenshot(s1.page, { format: "png" }),
+    takeScreenshot(s2.page, { format: "png" }),
+    getText(s1.page),
+    getText(s2.page)
+  ]);
+  const { diffImages: diffImages2 } = await Promise.resolve().then(() => (init_gallery_diff(), exports_gallery_diff));
+  const diff = await diffImages2(ss1.path, ss2.path);
+  const words1 = text1.split(/\s+/).filter(Boolean);
+  const words2 = text2.split(/\s+/).filter(Boolean);
+  const set1 = new Set(words1);
+  const set2 = new Set(words2);
+  const common = words1.filter((w) => set2.has(w)).length;
+  const textSimilarity = words1.length > 0 ? Math.round(common / Math.max(words1.length, words2.length) * 100) : 0;
+  const result = {
+    url1,
+    url2,
+    screenshot1: ss1.path,
+    screenshot2: ss2.path,
+    diff_image: diff.diff_path,
+    pixel_change_percent: +diff.changed_percent.toFixed(2),
+    text_similarity_percent: textSimilarity,
+    text1_length: text1.length,
+    text2_length: text2.length
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(chalk.bold(`URL Comparison:
+`));
+    console.log(chalk.blue(`  1: ${url1}`));
+    console.log(chalk.blue(`  2: ${url2}
+`));
+    console.log(`  Pixel diff:     ${diff.changed_percent > 5 ? chalk.red(result.pixel_change_percent + "%") : chalk.green(result.pixel_change_percent + "%")} changed`);
+    console.log(`  Text similarity: ${textSimilarity > 80 ? chalk.green(textSimilarity + "%") : chalk.yellow(textSimilarity + "%")}`);
+    console.log(chalk.gray(`
+  Screenshot 1: ${ss1.path}`));
+    console.log(chalk.gray(`  Screenshot 2: ${ss2.path}`));
+    console.log(chalk.gray(`  Diff image:   ${diff.diff_path}`));
+  }
+  await Promise.all([closeSession2(s1.session.id), closeSession2(s2.session.id)]);
+});
 program2.command("screenshot <url>").description("Navigate to a URL and take a screenshot").option("--engine <engine>", "Browser engine", "auto").option("--selector <selector>", "CSS selector for element screenshot").option("--full-page", "Capture full page").option("--format <format>", "Image format: png|jpeg|webp", "png").option("--headed", "Run in headed (visible) mode").action(async (url, opts) => {
   const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
   await navigate(page, url);
@@ -37067,6 +38264,86 @@ program2.command("attach").description("Attach to a running Chrome browser via C
     console.log(chalk.blue(`  Page: ${title} (${url})`));
   }
 });
+program2.command("login <url>").description("Login to a site: detect form, fill credentials from secrets, save auth state").option("--email <email>", "Email to login with").option("--save-as <name>", "Name to save storage state as").option("--engine <engine>", "Browser engine", "auto").option("--headed", "Run in headed (visible) mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
+  await navigate(page, url);
+  const formInfo = await page.evaluate(() => {
+    const emailInput = document.querySelector('input[type="email"], input[name="email"], input[name="username"], input[autocomplete="email"], input[autocomplete="username"]');
+    const passwordInput = document.querySelector('input[type="password"]');
+    const submitBtn = document.querySelector('button[type="submit"], input[type="submit"], button:has(span)');
+    return {
+      hasEmailInput: !!emailInput,
+      hasPasswordInput: !!passwordInput,
+      hasSubmitButton: !!submitBtn,
+      emailSelector: emailInput ? emailInput.id ? `#${emailInput.id}` : emailInput.name ? `input[name="${emailInput.name}"]` : 'input[type="email"]' : null,
+      passwordSelector: passwordInput ? passwordInput.id ? `#${passwordInput.id}` : 'input[type="password"]' : null,
+      submitSelector: submitBtn ? submitBtn.id ? `#${submitBtn.id}` : 'button[type="submit"]' : null,
+      pageTitle: document.title
+    };
+  });
+  if (!opts.json) {
+    console.log(chalk.gray(`Page: ${formInfo.pageTitle}`));
+    console.log(chalk.gray(`  Email input: ${formInfo.hasEmailInput ? "\u2713" : "\u2717"}`));
+    console.log(chalk.gray(`  Password input: ${formInfo.hasPasswordInput ? "\u2713" : "\u2717"}`));
+    console.log(chalk.gray(`  Submit button: ${formInfo.hasSubmitButton ? "\u2713" : "\u2717"}`));
+  }
+  let email = opts.email;
+  let password;
+  if (!email) {
+    try {
+      const { getCredentials: getCredentials2 } = await Promise.resolve().then(() => (init_auth(), exports_auth));
+      const hostname = new URL(url).hostname;
+      const creds = await getCredentials2(hostname);
+      if (creds) {
+        email = creds.email ?? creds.username;
+        password = creds.password;
+        if (!opts.json)
+          console.log(chalk.blue(`  Credentials found for ${hostname}`));
+      }
+    } catch {}
+  }
+  if (email && formInfo.emailSelector) {
+    await page.fill(formInfo.emailSelector, email);
+    if (!opts.json)
+      console.log(chalk.green(`  \u2713 Filled email: ${email}`));
+  }
+  if (password && formInfo.passwordSelector) {
+    await page.fill(formInfo.passwordSelector, password);
+    if (!opts.json)
+      console.log(chalk.green(`  \u2713 Filled password`));
+  }
+  if (formInfo.hasSubmitButton && formInfo.submitSelector) {
+    await page.click(formInfo.submitSelector);
+    if (!opts.json)
+      console.log(chalk.green(`  \u2713 Submitted form`));
+    try {
+      await page.waitForNavigation({ timeout: 1e4 });
+    } catch {}
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  const finalUrl = page.url();
+  const loggedIn = finalUrl !== url;
+  let savedAs;
+  if (opts.saveAs || loggedIn) {
+    const name = opts.saveAs ?? new URL(url).hostname.replace(/\./g, "-");
+    try {
+      const { saveStateFromPage: saveStateFromPage2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      await saveStateFromPage2(page, name);
+      savedAs = name;
+      if (!opts.json)
+        console.log(chalk.green(`  \u2713 State saved as: ${name}`));
+    } catch {}
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ session_id: session.id, url: finalUrl, logged_in: loggedIn, form_detected: formInfo.hasEmailInput, saved_as: savedAs }));
+  } else {
+    console.log(loggedIn ? chalk.green(`
+\u2713 Login successful \u2192 ${finalUrl}`) : chalk.yellow(`
+\u26A0 May need manual steps (magic link, 2FA, etc)`));
+  }
+  if (!opts.headed)
+    await closeSession2(session.id);
+});
 program2.command("install-browser").description("Install a browser engine").option("--engine <engine>", "Engine to install: lightpanda|chromium", "chromium").action(async (opts) => {
   if (opts.engine === "chromium") {
     const { execSync: execSync3 } = await import("child_process");
@@ -37082,6 +38359,124 @@ program2.command("install-browser").description("Install a browser engine").opti
     }
   }
 });
+var daemonCmd = program2.command("daemon").description("Manage the browser daemon (persistent background sessions)");
+daemonCmd.command("start").description("Start the browser daemon in the background").option("--port <port>", "Port to listen on", "7030").action(async (opts) => {
+  const { isDaemonRunning: isDaemonRunning2, getDaemonPidFile: getDaemonPidFile2, getDaemonStatus: getDaemonStatus2 } = await Promise.resolve().then(() => (init_daemon_client(), exports_daemon_client));
+  if (isDaemonRunning2()) {
+    console.log(chalk.yellow("Daemon is already running."));
+    const status = await getDaemonStatus2();
+    console.log(chalk.gray(`  PID: ${status.pid}, Port: ${status.port}, Sessions: ${status.sessions ?? "?"}`));
+    return;
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  const { writeFileSync: writeFileSync8, mkdirSync: mkdirSync14 } = await import("fs");
+  const { dirname: dirname4 } = await import("path");
+  const pidFile = getDaemonPidFile2();
+  mkdirSync14(dirname4(pidFile), { recursive: true });
+  const child = spawn2(process.execPath, [import.meta.dir + "/../server/index.js"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, BROWSER_SERVER_PORT: opts.port }
+  });
+  child.unref();
+  if (child.pid) {
+    writeFileSync8(pidFile, String(child.pid));
+    await new Promise((r) => setTimeout(r, 1500));
+    console.log(chalk.green(`\u2713 Daemon started`));
+    console.log(chalk.gray(`  PID: ${child.pid}, Port: ${opts.port}`));
+    console.log(chalk.gray(`  Sessions will persist across CLI invocations.`));
+    console.log(chalk.gray(`  Stop with: browser daemon stop`));
+  } else {
+    console.log(chalk.red("Failed to start daemon"));
+  }
+});
+daemonCmd.command("stop").description("Stop the browser daemon").action(async () => {
+  const { isDaemonRunning: isDaemonRunning2, getDaemonPid: getDaemonPid2, getDaemonPidFile: getDaemonPidFile2 } = await Promise.resolve().then(() => (init_daemon_client(), exports_daemon_client));
+  const { unlinkSync: unlinkSync4 } = await import("fs");
+  if (!isDaemonRunning2()) {
+    console.log(chalk.gray("Daemon is not running."));
+    return;
+  }
+  const pid = getDaemonPid2();
+  if (pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+    try {
+      unlinkSync4(getDaemonPidFile2());
+    } catch {}
+    console.log(chalk.green(`\u2713 Daemon stopped (PID: ${pid})`));
+  }
+});
+daemonCmd.command("status").description("Check daemon status").option("--json", "Output as JSON").action(async (opts) => {
+  const { getDaemonStatus: getDaemonStatus2 } = await Promise.resolve().then(() => (init_daemon_client(), exports_daemon_client));
+  const status = await getDaemonStatus2();
+  if (opts.json) {
+    console.log(JSON.stringify(status, null, 2));
+  } else if (status.running) {
+    console.log(chalk.green("\u25CF Daemon running"));
+    console.log(chalk.gray(`  PID: ${status.pid}`));
+    console.log(chalk.gray(`  Port: ${status.port}`));
+    if (status.sessions != null)
+      console.log(chalk.gray(`  Active sessions: ${status.sessions}`));
+    if (status.uptime_ms != null)
+      console.log(chalk.gray(`  Uptime: ${Math.round(status.uptime_ms / 1000)}s`));
+  } else {
+    console.log(chalk.gray("\u25CB Daemon not running"));
+    console.log(chalk.gray(`  Start with: browser daemon start`));
+  }
+});
+program2.command("watch <url>").description("Monitor a URL for changes \u2014 periodic screenshot + diff").option("--engine <engine>", "Browser engine", "auto").option("--interval <seconds>", "Check interval in seconds", "30").option("--threshold <percent>", "Change threshold percent to report", "5").option("--headed", "Run in headed mode").option("--json", "Output as JSON").action(async (url, opts) => {
+  const intervalMs = parseInt(opts.interval) * 1000;
+  const threshold = parseFloat(opts.threshold);
+  const { session, page } = await createSession2({ engine: opts.engine, headless: !opts.headed });
+  console.log(chalk.gray(`Watching: ${url} (every ${opts.interval}s, threshold ${opts.threshold}%)`));
+  console.log(chalk.gray(`Session: ${session.id} \u2014 Press Ctrl+C to stop
+`));
+  await navigate(page, url);
+  let baselineResult = await takeScreenshot(page, { format: "png" });
+  let baselinePath = baselineResult.path;
+  let checkCount = 0;
+  if (!opts.json)
+    console.log(chalk.blue(`[${new Date().toISOString()}] Baseline captured: ${baselinePath}`));
+  const check = async () => {
+    checkCount++;
+    try {
+      await page.reload({ waitUntil: "domcontentloaded" });
+      await new Promise((r) => setTimeout(r, 2000));
+      const newResult = await takeScreenshot(page, { format: "png" });
+      const { diffImages: diffImages2 } = await Promise.resolve().then(() => (init_gallery_diff(), exports_gallery_diff));
+      const diff = await diffImages2(baselinePath, newResult.path);
+      const changed = diff.changed_percent > threshold;
+      const timestamp = new Date().toISOString();
+      if (opts.json) {
+        console.log(JSON.stringify({ timestamp, check: checkCount, changed_percent: diff.changed_percent, changed, screenshot: newResult.path, diff_path: changed ? diff.diff_path : undefined }));
+      } else if (changed) {
+        console.log(chalk.red(`[${timestamp}] CHANGED: ${diff.changed_percent.toFixed(2)}% (${diff.changed_pixels} pixels)`));
+        console.log(chalk.gray(`  Screenshot: ${newResult.path}`));
+        console.log(chalk.gray(`  Diff: ${diff.diff_path}`));
+        baselinePath = newResult.path;
+      } else {
+        console.log(chalk.green(`[${timestamp}] No change (${diff.changed_percent.toFixed(2)}%)`));
+      }
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      if (opts.json) {
+        console.log(JSON.stringify({ timestamp: new Date().toISOString(), check: checkCount, error: msg }));
+      } else {
+        console.log(chalk.red(`[${new Date().toISOString()}] Error: ${msg}`));
+      }
+    }
+  };
+  const timer = setInterval(check, intervalMs);
+  process.on("SIGINT", async () => {
+    clearInterval(timer);
+    console.log(chalk.gray(`
+Stopping watch. ${checkCount} checks performed.`));
+    await closeSession2(session.id);
+    process.exit(0);
+  });
+});
 program2.command("mcp").description("Start the MCP server (stdio)").action(async () => {
   await init_mcp().then(() => exports_mcp);
 });
@@ -37158,11 +38553,11 @@ galleryCmd.command("stats").description("Show gallery statistics").option("--pro
 });
 galleryCmd.command("clean").description("Delete gallery entries with missing files").action(async () => {
   const { listEntries: listEntries2, deleteEntry: deleteEntry2 } = await Promise.resolve().then(() => (init_gallery(), exports_gallery));
-  const { existsSync: existsSync10 } = await import("fs");
+  const { existsSync: existsSync11 } = await import("fs");
   const entries = listEntries2({ limit: 9999 });
   let removed = 0;
   for (const e of entries) {
-    if (!existsSync10(e.path)) {
+    if (!existsSync11(e.path)) {
       deleteEntry2(e.id);
       removed++;
     }