opendevbrowser 0.0.11 → 0.0.12

package/dist/chunk-WTFSMBVH.js

@@ -0,0 +1,2815 @@
+// src/extension-extractor.ts
+import { existsSync, mkdirSync, cpSync, readFileSync, writeFileSync, rmSync, renameSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var EXTENSION_DIR_NAME = "opendevbrowser";
+var VERSION_FILE = ".version";
+function getConfigDir() {
+  return join(homedir(), ".config", "opencode", EXTENSION_DIR_NAME, "extension");
+}
+function getPackageVersion() {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch (error) {
+    console.warn("[opendevbrowser] Failed to read package.json for extension version:", error);
+    return "0.0.0";
+  }
+}
+function getInstalledVersion(destDir) {
+  try {
+    const versionPath = join(destDir, VERSION_FILE);
+    if (existsSync(versionPath)) {
+      return readFileSync(versionPath, "utf-8").trim();
+    }
+  } catch (error) {
+    console.warn("[opendevbrowser] Failed to read installed extension version:", error);
+  }
+  return null;
+}
+function getBundledExtensionPath() {
+  const candidates = [
+    join(dirname(fileURLToPath(import.meta.url)), "..", "extension"),
+    join(dirname(fileURLToPath(import.meta.url)), "..", "..", "extension")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "manifest.json"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isCompleteInstall(dir) {
+  const required = ["manifest.json", VERSION_FILE];
+  return required.every((file) => existsSync(join(dir, file)));
+}
+function extractExtension() {
+  const bundledPath = getBundledExtensionPath();
+  if (!bundledPath) {
+    return null;
+  }
+  const destDir = getConfigDir();
+  const currentVersion = getPackageVersion();
+  const installedVersion = getInstalledVersion(destDir);
+  if (installedVersion === currentVersion && isCompleteInstall(destDir)) {
+    return destDir;
+  }
+  const parentDir = dirname(destDir);
+  const stagingDir = join(parentDir, `.opendevbrowser-staging-${process.pid}-${Date.now()}`);
+  const backupDir = join(parentDir, `.opendevbrowser-backup-${process.pid}-${Date.now()}`);
+  try {
+    mkdirSync(stagingDir, { recursive: true });
+    const itemsToCopy = ["manifest.json", "popup.html", "dist", "icons"];
+    for (const item of itemsToCopy) {
+      const src = join(bundledPath, item);
+      const dest = join(stagingDir, item);
+      if (existsSync(src)) {
+        cpSync(src, dest, { recursive: true, force: true });
+      }
+    }
+    writeFileSync(join(stagingDir, VERSION_FILE), currentVersion, "utf-8");
+    if (!isCompleteInstall(stagingDir)) {
+      throw new Error("Staging directory incomplete after copy");
+    }
+    if (existsSync(destDir)) {
+      renameSync(destDir, backupDir);
+    }
+    renameSync(stagingDir, destDir);
+    if (existsSync(backupDir)) {
+      rmSync(backupDir, { recursive: true, force: true });
+    }
+    return destDir;
+  } catch (error) {
+    if (existsSync(backupDir) && !existsSync(destDir)) {
+      try {
+        renameSync(backupDir, destDir);
+      } catch (rollbackError) {
+        console.warn(`[opendevbrowser] Warning: Rollback failed for ${backupDir}:`, rollbackError);
+      }
+    }
+    if (existsSync(stagingDir)) {
+      try {
+        rmSync(stagingDir, { recursive: true, force: true });
+      } catch (stagingCleanupError) {
+        console.warn(`[opendevbrowser] Warning: Failed to clean up staging directory ${stagingDir}:`, stagingCleanupError);
+      }
+    }
+    if (existsSync(backupDir)) {
+      try {
+        rmSync(backupDir, { recursive: true, force: true });
+      } catch (backupCleanupError) {
+        console.warn(`[opendevbrowser] Warning: Failed to clean up backup directory ${backupDir}:`, backupCleanupError);
+      }
+    }
+    throw error;
+  }
+}
+function getExtensionPath() {
+  const destDir = getConfigDir();
+  if (isCompleteInstall(destDir)) {
+    return destDir;
+  }
+  return getBundledExtensionPath();
+}
+
+// src/browser/browser-manager.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir2, rm } from "fs/promises";
+import { join as join4 } from "path";
+import { chromium } from "playwright-core";
+import { Mutex } from "async-mutex";
+
+// src/cache/paths.ts
+import { createHash } from "crypto";
+import { mkdir, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function safeHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+async function ensureDir(path2) {
+  await mkdir(path2, { recursive: true });
+}
+async function resolveCachePaths(worktree, profile) {
+  const base = process.env.OPENCODE_CACHE_DIR ?? process.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache");
+  const root = join2(base, "opendevbrowser");
+  const projectRoot = join2(root, "projects", safeHash(worktree));
+  const profileDir = join2(projectRoot, "profiles", profile);
+  const chromeDir = join2(root, "chrome");
+  await ensureDir(root);
+  await ensureDir(projectRoot);
+  await ensureDir(profileDir);
+  await ensureDir(chromeDir);
+  return { root, projectRoot, profileDir, chromeDir };
+}
+
+// src/cache/chrome-locator.ts
+import { access } from "fs/promises";
+import { delimiter, join as join3 } from "path";
+async function pathExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathCandidatesByPlatform() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
+    ];
+  }
+  if (platform === "win32") {
+    const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+    const programFilesX86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+    const localAppData = process.env.LOCALAPPDATA || "";
+    return [
+      join3(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+      join3(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+      join3(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+    ];
+  }
+  return [];
+}
+function binaryCandidatesInPath() {
+  return [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser"
+  ];
+}
+async function findInPath(binary) {
+  const pathValue = process.env.PATH;
+  if (!pathValue) return null;
+  const candidates = process.platform === "win32" ? [binary, `${binary}.exe`] : [binary];
+  for (const dir of pathValue.split(delimiter)) {
+    for (const name of candidates) {
+      const fullPath = join3(dir, name);
+      if (await pathExists(fullPath)) return fullPath;
+    }
+  }
+  return null;
+}
+async function findChromeExecutable(overridePath) {
+  if (overridePath && await pathExists(overridePath)) {
+    return overridePath;
+  }
+  for (const candidate of pathCandidatesByPlatform()) {
+    if (await pathExists(candidate)) return candidate;
+  }
+  for (const binary of binaryCandidatesInPath()) {
+    const found = await findInPath(binary);
+    if (found) return found;
+  }
+  return null;
+}
+
+// src/cache/downloader.ts
+import { Browser, detectBrowserPlatform, install, resolveBuildId } from "@puppeteer/browsers";
+async function downloadChromeForTesting(cacheDir) {
+  const platform = detectBrowserPlatform();
+  if (!platform) {
+    throw new Error("Unsupported platform for Chrome download");
+  }
+  const buildId = await resolveBuildId(Browser.CHROME, platform, "latest");
+  const result = await install({
+    browser: Browser.CHROME,
+    buildId,
+    cacheDir,
+    downloadProgressCallback: () => void 0
+  });
+  return {
+    executablePath: result.executablePath,
+    buildId
+  };
+}
+
+// src/devtools/console-tracker.ts
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+var TOKEN_LIKE_PATTERN = /\b[A-Za-z0-9_-]{16,}\b/g;
+var API_KEY_PREFIX_PATTERN = /\b(sk_|pk_|api_|key_|token_|secret_|bearer_)[A-Za-z0-9_-]+\b/gi;
+var SENSITIVE_KV_PATTERN = /\b(token|key|secret|password|auth|bearer|credential)[=:]\s*\S+/gi;
+function shouldRedactToken(token) {
+  if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(token)) {
+    return true;
+  }
+  const categories = [
+    /[a-z]/.test(token),
+    /[A-Z]/.test(token),
+    /\d/.test(token),
+    /[_-]/.test(token)
+  ].filter(Boolean).length;
+  return categories >= 2;
+}
+function redactText(text) {
+  let result = text.replace(SENSITIVE_KV_PATTERN, (match) => {
+    const sepIndex = match.search(/[=:]/);
+    return match.slice(0, sepIndex + 1) + "[REDACTED]";
+  });
+  result = result.replace(JWT_PATTERN, "[REDACTED]");
+  result = result.replace(API_KEY_PREFIX_PATTERN, "[REDACTED]");
+  result = result.replace(TOKEN_LIKE_PATTERN, (match) => shouldRedactToken(match) ? "[REDACTED]" : match);
+  return result;
+}
+var ConsoleTracker = class {
+  events = [];
+  maxEvents;
+  seq = 0;
+  page = null;
+  handler;
+  showFullConsole;
+  constructor(maxEvents = 200, options = {}) {
+    this.maxEvents = maxEvents;
+    this.showFullConsole = options.showFullConsole ?? false;
+  }
+  setOptions(options) {
+    if (typeof options.showFullConsole === "boolean") {
+      this.showFullConsole = options.showFullConsole;
+    }
+  }
+  attach(page) {
+    if (this.page === page) return;
+    this.detach();
+    this.page = page;
+    this.handler = (msg) => {
+      const rawText = msg.text();
+      const text = this.showFullConsole ? rawText : redactText(rawText);
+      this.seq += 1;
+      this.events.push({
+        seq: this.seq,
+        level: msg.type(),
+        text,
+        ts: Date.now()
+      });
+      if (this.events.length > this.maxEvents) {
+        this.events.shift();
+      }
+    };
+    page.on("console", this.handler);
+  }
+  detach() {
+    if (this.page && this.handler) {
+      this.page.off("console", this.handler);
+    }
+    this.page = null;
+    this.handler = void 0;
+  }
+  poll(sinceSeq = 0, max = 50) {
+    const events = this.events.filter((event) => event.seq > sinceSeq).slice(0, max);
+    const last = events[events.length - 1];
+    const nextSeq = last ? last.seq : sinceSeq;
+    return { events, nextSeq };
+  }
+};
+
+// src/devtools/network-tracker.ts
+function shouldRedactPathSegment(segment) {
+  if (segment.length < 16) return false;
+  if (/^\d+$/.test(segment)) return false;
+  if (/^[a-f0-9-]{36}$/i.test(segment)) return false;
+  if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(segment)) return true;
+  const categories = [/[a-z]/, /[A-Z]/, /\d/, /[_-]/].filter((r) => r.test(segment)).length;
+  return categories >= 3 && segment.length >= 20;
+}
+function redactUrl(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl);
+    parsed.search = "";
+    parsed.hash = "";
+    const segments = parsed.pathname.split("/");
+    const redactedSegments = segments.map(
+      (segment) => shouldRedactPathSegment(segment) ? "[REDACTED]" : segment
+    );
+    parsed.pathname = redactedSegments.join("/");
+    return parsed.toString();
+  } catch {
+    return rawUrl.split(/[?#]/)[0] ?? rawUrl;
+  }
+}
+var NetworkTracker = class {
+  events = [];
+  maxEvents;
+  seq = 0;
+  page = null;
+  requestHandler;
+  responseHandler;
+  showFullUrls;
+  constructor(maxEvents = 300, options = {}) {
+    this.maxEvents = maxEvents;
+    this.showFullUrls = options.showFullUrls ?? false;
+  }
+  setOptions(options) {
+    if (typeof options.showFullUrls === "boolean") {
+      this.showFullUrls = options.showFullUrls;
+    }
+  }
+  attach(page) {
+    if (this.page === page) return;
+    this.detach();
+    this.page = page;
+    this.requestHandler = (req) => {
+      this.push({
+        method: req.method(),
+        url: this.showFullUrls ? req.url() : redactUrl(req.url()),
+        resourceType: req.resourceType(),
+        ts: Date.now()
+      });
+    };
+    this.responseHandler = (res) => {
+      const req = res.request();
+      this.push({
+        method: req.method(),
+        url: this.showFullUrls ? res.url() : redactUrl(res.url()),
+        status: res.status(),
+        resourceType: req.resourceType(),
+        ts: Date.now()
+      });
+    };
+    page.on("request", this.requestHandler);
+    page.on("response", this.responseHandler);
+  }
+  detach() {
+    if (this.page && this.requestHandler) {
+      this.page.off("request", this.requestHandler);
+    }
+    if (this.page && this.responseHandler) {
+      this.page.off("response", this.responseHandler);
+    }
+    this.page = null;
+    this.requestHandler = void 0;
+    this.responseHandler = void 0;
+  }
+  poll(sinceSeq = 0, max = 50) {
+    const events = this.events.filter((event) => event.seq > sinceSeq).slice(0, max);
+    const last = events[events.length - 1];
+    const nextSeq = last ? last.seq : sinceSeq;
+    return { events, nextSeq };
+  }
+  push(event) {
+    this.seq += 1;
+    this.events.push({
+      seq: this.seq,
+      ...event
+    });
+    if (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+  }
+};
+
+// src/export/css-extract.ts
+var STYLE_ALLOWLIST = /* @__PURE__ */ new Set([
+  "align-content",
+  "align-items",
+  "align-self",
+  "background",
+  "background-attachment",
+  "background-clip",
+  "background-color",
+  "background-image",
+  "background-origin",
+  "background-position",
+  "background-position-x",
+  "background-position-y",
+  "background-repeat",
+  "background-size",
+  "border",
+  "border-bottom",
+  "border-bottom-color",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-color",
+  "border-left",
+  "border-left-color",
+  "border-left-style",
+  "border-left-width",
+  "border-radius",
+  "border-right",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-style",
+  "border-top",
+  "border-top-color",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-top-style",
+  "border-top-width",
+  "border-width",
+  "box-shadow",
+  "box-sizing",
+  "color",
+  "column-gap",
+  "contain",
+  "direction",
+  "display",
+  "filter",
+  "flex",
+  "flex-direction",
+  "flex-flow",
+  "flex-wrap",
+  "font",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-variant",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variation-settings",
+  "font-weight",
+  "gap",
+  "grid",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows",
+  "height",
+  "hyphens",
+  "inset",
+  "inset-block",
+  "inset-inline",
+  "isolation",
+  "justify-content",
+  "left",
+  "letter-spacing",
+  "line-height",
+  "margin",
+  "margin-bottom",
+  "margin-left",
+  "margin-right",
+  "margin-top",
+  "max-height",
+  "max-width",
+  "min-height",
+  "min-width",
+  "opacity",
+  "outline",
+  "outline-color",
+  "outline-offset",
+  "outline-style",
+  "outline-width",
+  "overflow",
+  "overflow-wrap",
+  "overflow-x",
+  "overflow-y",
+  "padding",
+  "padding-bottom",
+  "padding-left",
+  "padding-right",
+  "padding-top",
+  "position",
+  "right",
+  "row-gap",
+  "text-align",
+  "text-align-last",
+  "text-decoration",
+  "text-decoration-color",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-decoration-thickness",
+  "text-indent",
+  "text-rendering",
+  "text-shadow",
+  "text-transform",
+  "top",
+  "transform",
+  "transform-origin",
+  "visibility",
+  "white-space",
+  "width",
+  "word-break",
+  "word-spacing",
+  "writing-mode",
+  "z-index"
+]);
+var SKIP_STYLE_VALUES = /* @__PURE__ */ new Set([
+  "",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function extractCss(capture) {
+  const shouldFilter = capture.inlineStyles !== false;
+  const lines = [];
+  lines.push(".opendevbrowser-root {");
+  for (const [key, value] of Object.entries(capture.styles)) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) continue;
+    if (shouldFilter) {
+      if (!STYLE_ALLOWLIST.has(key)) continue;
+      if (SKIP_STYLE_VALUES.has(trimmed)) continue;
+    }
+    lines.push(`  ${key}: ${value};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/export/dom-capture.ts
+var DEFAULT_MAX_NODES = 1e3;
+async function captureDom(page, selector, options = {}) {
+  const shouldSanitize = options.sanitize !== false;
+  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  const inlineStyles = options.inlineStyles !== false;
+  const styleAllowlist = Array.from(STYLE_ALLOWLIST);
+  const skipStyleValues = Array.from(SKIP_STYLE_VALUES);
+  return page.$eval(
+    selector,
+    (el, opts) => {
+      const style = window.getComputedStyle(el);
+      const styles = {};
+      for (const prop of Array.from(style)) {
+        styles[prop] = style.getPropertyValue(prop);
+      }
+      const warnings = [];
+      const root = el;
+      const clone = root.cloneNode(true);
+      const originalElements = [root, ...Array.from(root.querySelectorAll("*"))];
+      const cloneElements = [clone, ...Array.from(clone.querySelectorAll("*"))];
+      const nodeLimit = Math.max(1, opts.maxNodes);
+      if (originalElements.length > nodeLimit) {
+        const omitted = originalElements.length - nodeLimit;
+        warnings.push(`Export truncated at ${nodeLimit} nodes; ${omitted} nodes omitted.`);
+      }
+      const limit = Math.min(originalElements.length, nodeLimit);
+      if (opts.inlineStyles) {
+        const skipSet = new Set(opts.skipStyleValues);
+        for (let index = 0; index < limit; index += 1) {
+          const source = originalElements[index];
+          const target = cloneElements[index];
+          if (!source || !target) continue;
+          const computed = window.getComputedStyle(source);
+          const parts = [];
+          for (const prop of opts.styleAllowlist) {
+            const value = computed.getPropertyValue(prop).trim();
+            if (value && !skipSet.has(value)) {
+              parts.push(`${prop}: ${value};`);
+            }
+          }
+          if (parts.length > 0) {
+            target.setAttribute("style", parts.join(" "));
+          }
+        }
+      }
+      if (originalElements.length > nodeLimit) {
+        for (let index = nodeLimit; index < cloneElements.length; index += 1) {
+          const target = cloneElements[index];
+          if (target) {
+            target.remove();
+          }
+        }
+      }
+      const container = document.createElement("template");
+      container.content.appendChild(clone);
+      if (opts.shouldSanitize) {
+        const blockedTags = /* @__PURE__ */ new Set([
+          "script",
+          "iframe",
+          "object",
+          "embed",
+          "frame",
+          "frameset",
+          "applet",
+          "base",
+          "link",
+          "meta",
+          "noscript"
+        ]);
+        const urlAttrs = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "xlink:href", "srcset"]);
+        const isDangerousUrl = (value) => {
+          const normalized = value.trim().toLowerCase();
+          return normalized.startsWith("javascript:") || normalized.startsWith("data:") || normalized.startsWith("vbscript:");
+        };
+        const isDangerousSrcset = (value) => {
+          const entries = value.split(",");
+          return entries.some((entry) => {
+            const url = entry.trim().split(/\s+/)[0] ?? "";
+            return isDangerousUrl(url);
+          });
+        };
+        const DANGEROUS_CSS_PATTERNS = [
+          /url\s*\(/i,
+          /expression\s*\(/i,
+          /-moz-binding/i,
+          /behavior\s*:/i,
+          /javascript\s*:/i
+        ];
+        const sanitizeStyle = (styleValue) => {
+          let result = styleValue;
+          let wasModified = false;
+          for (const pattern of DANGEROUS_CSS_PATTERNS) {
+            if (pattern.test(result)) {
+              result = result.replace(new RegExp(pattern.source, "gi"), "/* blocked */");
+              wasModified = true;
+            }
+          }
+          return { sanitized: result, wasModified };
+        };
+        const sanitizeSvg = (svg) => {
+          const scripts = svg.querySelectorAll("script");
+          scripts.forEach((script) => {
+            script.remove();
+            warnings.push("Removed script element from SVG");
+          });
+          const foreignObjects = svg.querySelectorAll("foreignObject");
+          foreignObjects.forEach((fo) => {
+            fo.remove();
+            warnings.push("Removed foreignObject from SVG");
+          });
+          const allElements = svg.querySelectorAll("*");
+          allElements.forEach((el2) => {
+            for (const attr of Array.from(el2.attributes)) {
+              if (attr.name.toLowerCase().startsWith("on")) {
+                el2.removeAttribute(attr.name);
+              }
+            }
+          });
+        };
+        const sanitizeElement = (element) => {
+          const tag = element.tagName.toLowerCase();
+          if (blockedTags.has(tag)) {
+            element.remove();
+            return;
+          }
+          if (tag === "svg") {
+            sanitizeSvg(element);
+          }
+          for (const attr of Array.from(element.attributes)) {
+            const name = attr.name.toLowerCase();
+            if (name.startsWith("on")) {
+              element.removeAttribute(attr.name);
+              continue;
+            }
+            if (name === "style") {
+              const { sanitized, wasModified } = sanitizeStyle(attr.value);
+              if (wasModified) {
+                element.setAttribute("style", sanitized);
+                warnings.push("Sanitized dangerous CSS in style attribute");
+              }
+              continue;
+            }
+            if (urlAttrs.has(name)) {
+              const value = attr.value || "";
+              const dangerous = name === "srcset" ? isDangerousSrcset(value) : isDangerousUrl(value);
+              if (dangerous) {
+                element.removeAttribute(attr.name);
+              }
+            }
+          }
+        };
+        for (const element of Array.from(container.content.querySelectorAll("*"))) {
+          sanitizeElement(element);
+        }
+        if (container.content.firstElementChild) {
+          sanitizeElement(container.content.firstElementChild);
+        }
+      }
+      return { html: container.innerHTML, styles, warnings, inlineStyles: opts.inlineStyles };
+    },
+    { shouldSanitize, maxNodes, inlineStyles, styleAllowlist, skipStyleValues }
+  );
+}
+
+// src/export/react-emitter.ts
+function emitReactComponent(capture, css, options = {}) {
+  const warnings = [...capture.warnings ?? []];
+  if (options.allowUnsafeExport) {
+    warnings.push("Unsafe export enabled: HTML sanitization disabled.");
+  }
+  const warningComment = options.allowUnsafeExport ? "// WARNING: Unsafe export enabled. HTML sanitization disabled.\n" : "";
+  const component = `${warningComment}import "./opendevbrowser.css";
+
+export default function OpenDevBrowserComponent() {
+  return (
+    <div className="opendevbrowser-root" dangerouslySetInnerHTML={{ __html: ${JSON.stringify(capture.html)} }} />
+  );
+}`;
+  return { component, css, warnings: warnings.length > 0 ? warnings : void 0 };
+}
+
+// src/snapshot/refs.ts
+import { randomUUID } from "crypto";
+var RefStore = class {
+  refsByTarget = /* @__PURE__ */ new Map();
+  snapshotByTarget = /* @__PURE__ */ new Map();
+  setSnapshot(targetId, entries) {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      map.set(entry.ref, entry);
+    }
+    const snapshotId = randomUUID();
+    this.refsByTarget.set(targetId, map);
+    this.snapshotByTarget.set(targetId, snapshotId);
+    return { snapshotId, targetId, count: entries.length };
+  }
+  resolve(targetId, ref) {
+    const map = this.refsByTarget.get(targetId);
+    if (!map) return null;
+    return map.get(ref) ?? null;
+  }
+  getSnapshotId(targetId) {
+    return this.snapshotByTarget.get(targetId) ?? null;
+  }
+  getRefCount(targetId) {
+    const map = this.refsByTarget.get(targetId);
+    return map ? map.size : 0;
+  }
+  clearTarget(targetId) {
+    this.refsByTarget.delete(targetId);
+    this.snapshotByTarget.delete(targetId);
+  }
+};
+
+// src/snapshot/snapshotter.ts
+var Snapshotter = class {
+  refStore;
+  constructor(refStore) {
+    this.refStore = refStore;
+  }
+  async snapshot(page, targetId, options) {
+    const startTime = Date.now();
+    const session = await page.context().newCDPSession(page);
+    let snapshotData;
+    try {
+      snapshotData = await buildSnapshot(session, options.mode, options.mainFrameOnly ?? true, options.maxNodes);
+    } finally {
+      await session.detach();
+    }
+    const snapshot = this.refStore.setSnapshot(targetId, snapshotData.entries);
+    const formatted = snapshotData.lines;
+    const startIndex = parseCursor(options.cursor);
+    const { content, truncated, nextCursor } = paginate(formatted, startIndex, options.maxChars);
+    const timingMs = Date.now() - startTime;
+    let url;
+    let title;
+    try {
+      url = page.url();
+      title = await page.title();
+    } catch (_err) {
+      void _err;
+      url = void 0;
+      title = void 0;
+    }
+    return {
+      snapshotId: snapshot.snapshotId,
+      url,
+      title,
+      content,
+      truncated,
+      nextCursor,
+      refCount: snapshot.count,
+      timingMs,
+      warnings: snapshotData.warnings
+    };
+  }
+};
+var DEFAULT_MAX_AX_NODES = 1e3;
+var ACTIONABLE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "searchbox",
+  "textarea",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "switch",
+  "tab",
+  "slider",
+  "spinbutton",
+  "treeitem"
+]);
+var SEMANTIC_ROLES = /* @__PURE__ */ new Set([
+  "heading",
+  "article",
+  "main",
+  "navigation",
+  "region",
+  "section",
+  "form",
+  "list",
+  "listitem",
+  "paragraph",
+  "img",
+  "table",
+  "row",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "banner",
+  "contentinfo",
+  "complementary"
+]);
+var selectorFunction = function() {
+  if (!(this instanceof Element)) return null;
+  const escape = (value) => {
+    if (typeof CSS !== "undefined" && CSS.escape) {
+      return CSS.escape(value);
+    }
+    return String(value).replace(/([^\w-])/g, "\\$1");
+  };
+  const testId = this.getAttribute("data-testid");
+  if (testId) {
+    return '[data-testid="' + escape(testId) + '"]';
+  }
+  const ariaLabel = this.getAttribute("aria-label");
+  if (ariaLabel && ariaLabel.length < 50) {
+    return '[aria-label="' + escape(ariaLabel) + '"]';
+  }
+  const buildPathSelector = (start) => {
+    const parts = [];
+    let current = start;
+    while (current && current.nodeType === Node.ELEMENT_NODE) {
+      let selector = current.nodeName.toLowerCase();
+      if (current.id) {
+        selector += "#" + escape(current.id);
+        parts.unshift(selector);
+        break;
+      }
+      const parentEl = current.parentElement;
+      if (!parentEl) {
+        parts.unshift(selector);
+        break;
+      }
+      let index = 1;
+      let sibling = current;
+      while (sibling && sibling.previousElementSibling) {
+        sibling = sibling.previousElementSibling;
+        index += 1;
+      }
+      selector += ":nth-child(" + index + ")";
+      parts.unshift(selector);
+      current = parentEl;
+    }
+    return parts.join(" > ");
+  };
+  return buildPathSelector(this);
+};
+var SELECTOR_FUNCTION = selectorFunction.toString();
+async function buildSnapshot(session, mode, mainFrameOnly = true, maxNodes) {
+  await session.send("Accessibility.enable");
+  await session.send("DOM.enable");
+  const result = await session.send("Accessibility.getFullAXTree");
+  const nodes = Array.isArray(result.nodes) ? result.nodes : [];
+  const entries = [];
+  const lines = [];
+  const warnings = [];
+  const maxEntries = typeof maxNodes === "number" ? maxNodes : DEFAULT_MAX_AX_NODES;
+  let skippedFrameCount = 0;
+  for (const node of nodes) {
+    if (entries.length >= maxEntries) break;
+    if (node.ignored) continue;
+    if (typeof node.backendDOMNodeId !== "number") continue;
+    if (mainFrameOnly && node.frameId) {
+      skippedFrameCount += 1;
+      continue;
+    }
+    const role = extractValue(node.role) || extractValue(node.chromeRole);
+    if (!role) continue;
+    if (!shouldInclude(role, mode)) continue;
+    const selector = await resolveSelector(session, node.backendDOMNodeId);
+    if (!selector) continue;
+    const ref = `r${entries.length + 1}`;
+    const name = redactText2(extractValue(node.name));
+    const value = redactText2(extractValue(node.value));
+    const disabled = isTruthyProperty(node.properties, "disabled");
+    const checked = isTruthyProperty(node.properties, "checked");
+    entries.push({
+      ref,
+      selector,
+      backendNodeId: node.backendDOMNodeId,
+      frameId: node.frameId,
+      role,
+      name
+    });
+    lines.push(formatNode({
+      ref,
+      role,
+      name,
+      value,
+      disabled,
+      checked
+    }));
+  }
+  if (mainFrameOnly && skippedFrameCount > 0) {
+    warnings.push(`Skipped ${skippedFrameCount} iframe nodes; snapshot limited to main frame.`);
+  }
+  return { entries, lines, warnings };
+}
+async function resolveSelector(session, backendNodeId) {
+  const resolved = await session.send("DOM.resolveNode", { backendNodeId });
+  const objectId = resolved.object?.objectId;
+  if (!objectId) return null;
+  const result = await session.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: SELECTOR_FUNCTION,
+    returnByValue: true
+  });
+  const selector = result.result?.value;
+  if (typeof selector !== "string" || selector.trim().length === 0) {
+    return null;
+  }
+  return selector;
+}
+function shouldInclude(role, mode) {
+  const normalized = role.toLowerCase();
+  if (ACTIONABLE_ROLES.has(normalized)) return true;
+  if (mode === "actionables") return false;
+  return SEMANTIC_ROLES.has(normalized);
+}
+function parseCursor(cursor) {
+  if (!cursor) return 0;
+  const value = Number(cursor);
+  if (!Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
+}
+function paginate(lines, startIndex, maxChars) {
+  let total = 0;
+  const parts = [];
+  let idx = startIndex;
+  while (idx < lines.length) {
+    const line = lines[idx];
+    if (line === void 0) {
+      break;
+    }
+    if (total + line.length + 1 > maxChars && parts.length > 0) {
+      break;
+    }
+    parts.push(line);
+    total += line.length + 1;
+    idx += 1;
+  }
+  const truncated = idx < lines.length;
+  const nextCursor = truncated ? String(idx) : void 0;
+  return {
+    content: parts.join("\n"),
+    truncated,
+    nextCursor
+  };
+}
+function formatNode(node) {
+  const name = redactText2(node.name || "");
+  const value = redactText2(node.value || "");
+  const parts = [];
+  parts.push(`[${node.ref}]`);
+  parts.push(node.role);
+  if (node.disabled) {
+    parts.push("disabled");
+  }
+  if (node.checked) {
+    parts.push("checked");
+  }
+  if (name) {
+    parts.push(`"${name}"`);
+  }
+  if (value) {
+    parts.push(`value="${value}"`);
+  }
+  return parts.join(" ");
+}
+function redactText2(text) {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return "";
+  return trimmed.replace(/[A-Za-z0-9+/_-]{24,}/g, "[redacted]");
+}
+function extractValue(value) {
+  if (!value || typeof value.value === "undefined" || value.value === null) return "";
+  if (typeof value.value === "string") return value.value;
+  if (typeof value.value === "number" || typeof value.value === "boolean") {
+    return String(value.value);
+  }
+  return "";
+}
+function isTruthyProperty(properties, name) {
+  if (!properties) return false;
+  const found = properties.find((prop) => prop.name === name);
+  if (!found || !found.value) return false;
+  const value = found.value.value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true";
+  if (typeof value === "number") return value !== 0;
+  return false;
+}
+
+// src/browser/session-store.ts
+var SessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  add(session) {
+    this.sessions.set(session.id, session);
+  }
+  get(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Unknown sessionId: ${sessionId}`);
+    }
+    return session;
+  }
+  has(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  delete(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  list() {
+    return Array.from(this.sessions.values());
+  }
+};
+
+// src/browser/target-manager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var TargetManager = class {
+  targets = /* @__PURE__ */ new Map();
+  activeTargetId = null;
+  nameToTarget = /* @__PURE__ */ new Map();
+  targetToName = /* @__PURE__ */ new Map();
+  registerPage(page, name) {
+    const targetId = randomUUID2();
+    this.targets.set(targetId, page);
+    if (!this.activeTargetId) {
+      this.activeTargetId = targetId;
+    }
+    if (name) {
+      this.setName(targetId, name);
+    }
+    return targetId;
+  }
+  registerExistingPages(pages) {
+    for (const page of pages) {
+      this.registerPage(page);
+    }
+  }
+  setName(targetId, name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+      throw new Error("Name must be non-empty");
+    }
+    if (!this.targets.has(targetId)) {
+      throw new Error(`Unknown targetId: ${targetId}`);
+    }
+    const existing = this.nameToTarget.get(trimmed);
+    if (existing && existing !== targetId) {
+      throw new Error(`Name already in use: ${trimmed}`);
+    }
+    const previousName = this.targetToName.get(targetId);
+    if (previousName && previousName !== trimmed) {
+      this.nameToTarget.delete(previousName);
+    }
+    this.nameToTarget.set(trimmed, targetId);
+    this.targetToName.set(targetId, trimmed);
+  }
+  getTargetIdByName(name) {
+    return this.nameToTarget.get(name.trim()) ?? null;
+  }
+  getName(targetId) {
+    return this.targetToName.get(targetId) ?? null;
+  }
+  listNamedTargets() {
+    return Array.from(this.nameToTarget.entries()).map(([name, targetId]) => ({
+      name,
+      targetId
+    }));
+  }
+  removeName(name) {
+    const trimmed = name.trim();
+    const targetId = this.nameToTarget.get(trimmed);
+    if (targetId) {
+      this.nameToTarget.delete(trimmed);
+      this.targetToName.delete(targetId);
+    }
+  }
+  setActiveTarget(targetId) {
+    if (!this.targets.has(targetId)) {
+      throw new Error(`Unknown targetId: ${targetId}`);
+    }
+    this.activeTargetId = targetId;
+  }
+  getActiveTargetId() {
+    return this.activeTargetId;
+  }
+  getActivePage() {
+    if (!this.activeTargetId) {
+      throw new Error("No active target");
+    }
+    const page = this.targets.get(this.activeTargetId);
+    if (!page) {
+      throw new Error(`Missing active target: ${this.activeTargetId}`);
+    }
+    return page;
+  }
+  getPage(targetId) {
+    const page = this.targets.get(targetId);
+    if (!page) {
+      throw new Error(`Unknown targetId: ${targetId}`);
+    }
+    return page;
+  }
+  async listTargets(includeUrls = false) {
+    const entries = Array.from(this.targets.entries());
+    return Promise.all(entries.map(async ([targetId, page]) => {
+      const info = {
+        targetId,
+        title: void 0,
+        url: void 0,
+        type: "page"
+      };
+      try {
+        info.title = await page.title();
+      } catch {
+        info.title = void 0;
+      }
+      if (includeUrls) {
+        try {
+          info.url = page.url();
+        } catch {
+          info.url = void 0;
+        }
+      }
+      return info;
+    }));
+  }
+  async closeTarget(targetId) {
+    const page = this.getPage(targetId);
+    let closeError;
+    try {
+      await page.close();
+    } catch (error) {
+      closeError = error;
+    } finally {
+      this.targets.delete(targetId);
+      const name = this.targetToName.get(targetId);
+      if (name) {
+        this.nameToTarget.delete(name);
+        this.targetToName.delete(targetId);
+      }
+      if (this.activeTargetId === targetId) {
+        const remaining = Array.from(this.targets.keys());
+        this.activeTargetId = remaining[0] ?? null;
+      }
+    }
+    if (closeError) {
+      throw closeError;
+    }
+  }
+  listPageEntries() {
+    return Array.from(this.targets.entries()).map(([targetId, page]) => ({
+      targetId,
+      page
+    }));
+  }
+};
+
+// src/browser/browser-manager.ts
+var BrowserManager = class {
+  store = new SessionStore();
+  sessions = /* @__PURE__ */ new Map();
+  sessionMutexes = /* @__PURE__ */ new Map();
+  worktree;
+  config;
+  pageListeners = /* @__PURE__ */ new WeakMap();
+  constructor(worktree, config) {
+    this.worktree = worktree;
+    this.config = config;
+  }
+  getMutex(sessionId) {
+    let mutex = this.sessionMutexes.get(sessionId);
+    if (!mutex) {
+      mutex = new Mutex();
+      this.sessionMutexes.set(sessionId, mutex);
+    }
+    return mutex;
+  }
+  updateConfig(config) {
+    this.config = config;
+    for (const managed of this.sessions.values()) {
+      managed.consoleTracker.setOptions({ showFullConsole: config.devtools.showFullConsole });
+      managed.networkTracker.setOptions({ showFullUrls: config.devtools.showFullUrls });
+    }
+  }
+  async launch(options) {
+    const resolvedProfile = options.profile ?? this.config.profile;
+    const resolvedHeadless = options.headless ?? this.config.headless;
+    const persistProfile = options.persistProfile ?? this.config.persistProfile;
+    const cachePaths = await resolveCachePaths(this.worktree, resolvedProfile);
+    const executable = await findChromeExecutable(options.chromePath ?? this.config.chromePath);
+    const warnings = [];
+    let executablePath = executable;
+    if (!executablePath) {
+      const download = await downloadChromeForTesting(cachePaths.chromeDir);
+      warnings.push("System Chrome not found. Downloaded Chrome for Testing.");
+      executablePath = download.executablePath;
+    }
+    const profileDir = persistProfile ? cachePaths.profileDir : join4(cachePaths.projectRoot, "temp-profiles", randomUUID3());
+    await mkdir2(profileDir, { recursive: true });
+    let context = null;
+    try {
+      context = await chromium.launchPersistentContext(profileDir, {
+        headless: resolvedHeadless,
+        executablePath: executablePath ?? void 0,
+        args: options.flags ?? this.config.flags,
+        viewport: null
+      });
+      const browser = context.browser();
+      if (!browser) {
+        throw new Error("Browser instance unavailable");
+      }
+      const sessionId = randomUUID3();
+      const targets = new TargetManager();
+      const pages = context.pages();
+      if (pages.length === 0) {
+        const page = await context.newPage();
+        targets.registerPage(page);
+      } else {
+        targets.registerExistingPages(pages);
+      }
+      const activeTargetId = targets.getActiveTargetId();
+      if (options.startUrl && activeTargetId) {
+        await this.goto(sessionId, options.startUrl, "load", 3e4, { browser, context, targets });
+      }
+      const refStore = new RefStore();
+      const snapshotter = new Snapshotter(refStore);
+      const consoleTracker = new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole });
+      const networkTracker = new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls });
+      const managed = {
+        sessionId,
+        mode: "A",
+        browser,
+        context,
+        profileDir,
+        persistProfile,
+        targets,
+        refStore,
+        snapshotter,
+        consoleTracker,
+        networkTracker
+      };
+      this.store.add({ id: sessionId, mode: "A", browser, context });
+      this.sessions.set(sessionId, managed);
+      this.attachTrackers(managed);
+      this.attachRefInvalidation(managed);
+      const wsEndpointProvider = browser;
+      const wsEndpoint = typeof wsEndpointProvider.wsEndpoint === "function" ? wsEndpointProvider.wsEndpoint() : void 0;
+      return { sessionId, mode: "A", activeTargetId, warnings, wsEndpoint: wsEndpoint || void 0 };
+    } catch (error) {
+      const launchMessage = error instanceof Error ? error.message : "Unknown error";
+      const cleanupErrors = [];
+      if (context) {
+        try {
+          await context.close();
+        } catch (closeError) {
+          cleanupErrors.push(closeError);
+        }
+      }
+      if (!persistProfile) {
+        try {
+          await rm(profileDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        } catch (cleanupError) {
+          cleanupErrors.push(cleanupError);
+        }
+      }
+      if (cleanupErrors.length > 0) {
+        throw new AggregateError(
+          [error, ...cleanupErrors],
+          `Failed to launch browser context: ${launchMessage}. Cleanup failed.`
+        );
+      }
+      throw new Error(`Failed to launch browser context: ${launchMessage}`, { cause: error });
+    }
+  }
+  async connect(options) {
+    const wsEndpoint = await this.resolveWsEndpoint(options);
+    return this.connectWithEndpoint(wsEndpoint, "B");
+  }
+  async connectRelay(wsEndpoint) {
+    this.ensureLocalEndpoint(wsEndpoint);
+    return this.connectWithEndpoint(wsEndpoint, "C");
+  }
+  async closeAll() {
+    const sessions = Array.from(this.sessions.keys());
+    await Promise.allSettled(sessions.map((id) => this.disconnect(id, true)));
+  }
+  async disconnect(sessionId, closeBrowser = false) {
+    const managed = this.getManaged(sessionId);
+    const cleanupErrors = [];
+    try {
+      for (const entry of managed.targets.listPageEntries()) {
+        const cleanup = this.pageListeners.get(entry.page);
+        if (cleanup) {
+          try {
+            cleanup();
+          } catch (error) {
+            cleanupErrors.push(error);
+          }
+          this.pageListeners.delete(entry.page);
+        }
+      }
+      try {
+        if (closeBrowser) {
+          await managed.browser.close();
+        } else {
+          await managed.context.close();
+        }
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      try {
+        managed.consoleTracker.detach();
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      try {
+        managed.networkTracker.detach();
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      if (!managed.persistProfile && managed.profileDir) {
+        try {
+          await rm(managed.profileDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        } catch (error) {
+          cleanupErrors.push(error);
+        }
+      }
+    } finally {
+      this.sessions.delete(sessionId);
+      this.sessionMutexes.delete(sessionId);
+      this.store.delete(sessionId);
+    }
+    if (cleanupErrors.length === 1) {
+      throw cleanupErrors[0];
+    }
+    if (cleanupErrors.length > 1) {
+      throw new AggregateError(cleanupErrors, "Failed to disconnect browser session.");
+    }
+  }
+  async status(sessionId) {
+    const managed = this.getManaged(sessionId);
+    const activeTargetId = managed.targets.getActiveTargetId();
+    const page = activeTargetId ? managed.targets.getPage(activeTargetId) : null;
+    const title = await this.safePageTitle(page, "BrowserManager.status");
+    const url = this.safePageUrl(page, "BrowserManager.status");
+    return {
+      mode: managed.mode,
+      activeTargetId,
+      url,
+      title
+    };
+  }
+  async listTargets(sessionId, includeUrls = false) {
+    const managed = this.getManaged(sessionId);
+    const targets = await managed.targets.listTargets(includeUrls);
+    return {
+      activeTargetId: managed.targets.getActiveTargetId(),
+      targets
+    };
+  }
+  async page(sessionId, name, url) {
+    const managed = this.getManaged(sessionId);
+    const existingTargetId = managed.targets.getTargetIdByName(name);
+    let targetId = existingTargetId;
+    let created = false;
+    if (targetId) {
+      managed.targets.setActiveTarget(targetId);
+    } else {
+      const page2 = await managed.context.newPage();
+      targetId = managed.targets.registerPage(page2, name);
+      managed.targets.setActiveTarget(targetId);
+      this.attachRefInvalidationForPage(managed, targetId, page2);
+      created = true;
+    }
+    this.attachTrackers(managed);
+    if (url) {
+      await this.goto(sessionId, url, "load", 3e4);
+    }
+    const page = managed.targets.getPage(targetId);
+    const title = await this.safePageTitle(page, "BrowserManager.page");
+    const finalUrl = this.safePageUrl(page, "BrowserManager.page");
+    return { targetId, created, url: finalUrl, title };
+  }
+  async listPages(sessionId) {
+    const managed = this.getManaged(sessionId);
+    const named = managed.targets.listNamedTargets();
+    const pages = [];
+    for (const entry of named) {
+      const page = managed.targets.getPage(entry.targetId);
+      const title = await this.safePageTitle(page, "BrowserManager.listPages");
+      const url = this.safePageUrl(page, "BrowserManager.listPages");
+      pages.push({ name: entry.name, targetId: entry.targetId, url, title });
+    }
+    return { pages };
+  }
+  async closePage(sessionId, name) {
+    const managed = this.getManaged(sessionId);
+    const targetId = managed.targets.getTargetIdByName(name);
+    if (!targetId) {
+      throw new Error(`Unknown page name: ${name}`);
+    }
+    await managed.targets.closeTarget(targetId);
+    managed.refStore.clearTarget(targetId);
+    this.attachTrackers(managed);
+  }
+  async useTarget(sessionId, targetId) {
+    const managed = this.getManaged(sessionId);
+    managed.targets.setActiveTarget(targetId);
+    this.attachTrackers(managed);
+    const page = managed.targets.getPage(targetId);
+    const title = await this.safePageTitle(page, "BrowserManager.useTarget");
+    return {
+      activeTargetId: targetId,
+      url: this.safePageUrl(page, "BrowserManager.useTarget"),
+      title
+    };
+  }
+  async newTarget(sessionId, url) {
+    const managed = this.getManaged(sessionId);
+    const page = await managed.context.newPage();
+    const targetId = managed.targets.registerPage(page);
+    managed.targets.setActiveTarget(targetId);
+    this.attachRefInvalidationForPage(managed, targetId, page);
+    if (url) {
+      await page.goto(url, { waitUntil: "load" });
+    }
+    this.attachTrackers(managed);
+    return { targetId };
+  }
+  async closeTarget(sessionId, targetId) {
+    const managed = this.getManaged(sessionId);
+    await managed.targets.closeTarget(targetId);
+    managed.refStore.clearTarget(targetId);
+    this.attachTrackers(managed);
+  }
+  async goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4, sessionOverride) {
+    const startTime = Date.now();
+    const managed = sessionOverride ? this.buildOverrideSession(sessionOverride) : this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    const response = await page.goto(url, { waitUntil, timeout: timeoutMs });
+    return {
+      finalUrl: page.url(),
+      status: response?.status(),
+      timingMs: Date.now() - startTime
+    };
+  }
+  async waitForLoad(sessionId, until, timeoutMs = 3e4) {
+    const startTime = Date.now();
+    const managed = this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    await page.waitForLoadState(until, { timeout: timeoutMs });
+    return { timingMs: Date.now() - startTime };
+  }
+  async waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4) {
+    const startTime = Date.now();
+    const managed = this.getManaged(sessionId);
+    const selector = this.resolveSelector(managed, ref);
+    const page = managed.targets.getActivePage();
+    await page.locator(selector).waitFor({ state, timeout: timeoutMs });
+    return { timingMs: Date.now() - startTime };
+  }
+  async snapshot(sessionId, mode, maxChars, cursor) {
+    const mutex = this.getMutex(sessionId);
+    return mutex.runExclusive(async () => {
+      const managed = this.getManaged(sessionId);
+      const targetId = managed.targets.getActiveTargetId();
+      if (!targetId) {
+        throw new Error("No active target for snapshot");
+      }
+      const page = managed.targets.getActivePage();
+      return managed.snapshotter.snapshot(page, targetId, {
+        mode,
+        maxChars,
+        cursor,
+        maxNodes: this.config.snapshot.maxNodes
+      });
+    });
+  }
+  async click(sessionId, ref) {
+    const mutex = this.getMutex(sessionId);
+    return mutex.runExclusive(async () => {
+      const startTime = Date.now();
+      const managed = this.getManaged(sessionId);
+      const selector = this.resolveSelector(managed, ref);
+      const page = managed.targets.getActivePage();
+      const previousUrl = page.url();
+      await page.locator(selector).click();
+      const navigated = page.url() !== previousUrl;
+      return { timingMs: Date.now() - startTime, navigated };
+    });
+  }
+  async type(sessionId, ref, text, clear = false, submit = false) {
+    const mutex = this.getMutex(sessionId);
+    return mutex.runExclusive(async () => {
+      const startTime = Date.now();
+      const managed = this.getManaged(sessionId);
+      const selector = this.resolveSelector(managed, ref);
+      const locator = managed.targets.getActivePage().locator(selector);
+      if (clear) {
+        await locator.fill("");
+      }
+      await locator.fill(text);
+      if (submit) {
+        await locator.press("Enter");
+      }
+      return { timingMs: Date.now() - startTime };
+    });
+  }
+  async select(sessionId, ref, values) {
+    const managed = this.getManaged(sessionId);
+    const selector = this.resolveSelector(managed, ref);
+    await managed.targets.getActivePage().locator(selector).selectOption(values);
+  }
+  async scroll(sessionId, dy, ref) {
+    const managed = this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    if (ref) {
+      const selector = this.resolveSelector(managed, ref);
+      await page.locator(selector).evaluate((el, delta) => {
+        el.scrollBy(0, delta);
+      }, dy);
+    } else {
+      await page.mouse.wheel(0, dy);
+    }
+  }
+  async domGetHtml(sessionId, ref, maxChars = 8e3) {
+    const managed = this.getManaged(sessionId);
+    const selector = this.resolveSelector(managed, ref);
+    const html = await managed.targets.getActivePage().$eval(selector, (el) => el.outerHTML);
+    return truncateHtml(html, maxChars);
+  }
+  async domGetText(sessionId, ref, maxChars = 8e3) {
+    const managed = this.getManaged(sessionId);
+    const selector = this.resolveSelector(managed, ref);
+    const text = await managed.targets.getActivePage().$eval(selector, (el) => el.innerText || el.textContent || "");
+    return truncateText(text, maxChars);
+  }
+  async clonePage(sessionId) {
+    const managed = this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    const allowUnsafeExport = this.config.security.allowUnsafeExport;
+    const exportConfig = this.config.export;
+    const capture = await captureDom(page, "body", {
+      sanitize: !allowUnsafeExport,
+      maxNodes: exportConfig.maxNodes,
+      inlineStyles: exportConfig.inlineStyles
+    });
+    const css = extractCss(capture);
+    return emitReactComponent(capture, css, { allowUnsafeExport });
+  }
+  async cloneComponent(sessionId, ref) {
+    const managed = this.getManaged(sessionId);
+    const selector = this.resolveSelector(managed, ref);
+    const allowUnsafeExport = this.config.security.allowUnsafeExport;
+    const exportConfig = this.config.export;
+    const capture = await captureDom(managed.targets.getActivePage(), selector, {
+      sanitize: !allowUnsafeExport,
+      maxNodes: exportConfig.maxNodes,
+      inlineStyles: exportConfig.inlineStyles
+    });
+    const css = extractCss(capture);
+    return emitReactComponent(capture, css, { allowUnsafeExport });
+  }
+  async perfMetrics(sessionId) {
+    const managed = this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    const session = await managed.context.newCDPSession(page);
+    const result = await session.send("Performance.getMetrics");
+    await session.detach();
+    const metrics = Array.isArray(result.metrics) ? result.metrics : [];
+    return { metrics };
+  }
+  async screenshot(sessionId, path2) {
+    const managed = this.getManaged(sessionId);
+    const page = managed.targets.getActivePage();
+    if (path2) {
+      await page.screenshot({ path: path2, type: "png" });
+      return { path: path2 };
+    }
+    const buffer = await page.screenshot({ type: "png" });
+    return { base64: buffer.toString("base64") };
+  }
+  consolePoll(sessionId, sinceSeq, max = 50) {
+    const managed = this.getManaged(sessionId);
+    return managed.consoleTracker.poll(sinceSeq, max);
+  }
+  networkPoll(sessionId, sinceSeq, max = 50) {
+    const managed = this.getManaged(sessionId);
+    return managed.networkTracker.poll(sinceSeq, max);
+  }
+  buildOverrideSession(input) {
+    const refStore = new RefStore();
+    return {
+      sessionId: "override",
+      mode: "A",
+      browser: input.browser,
+      context: input.context,
+      profileDir: "",
+      persistProfile: true,
+      targets: input.targets,
+      refStore,
+      snapshotter: new Snapshotter(refStore),
+      consoleTracker: new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole }),
+      networkTracker: new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls })
+    };
+  }
+  getManaged(sessionId) {
+    const managed = this.sessions.get(sessionId);
+    if (!managed) {
+      throw new Error(`Unknown sessionId: ${sessionId}`);
+    }
+    return managed;
+  }
+  resolveSelector(managed, ref) {
+    const targetId = managed.targets.getActiveTargetId();
+    if (!targetId) {
+      throw new Error("No active target for ref resolution");
+    }
+    const entry = managed.refStore.resolve(targetId, ref);
+    if (!entry) {
+      throw new Error(`Unknown ref: ${ref}. Take a new snapshot first.`);
+    }
+    return entry.selector;
+  }
+  async safePageTitle(page, context) {
+    if (!page) return void 0;
+    try {
+      return await page.title();
+    } catch {
+      console.warn(`${context}: failed to read page title`);
+      return void 0;
+    }
+  }
+  safePageUrl(page, context) {
+    if (!page) return void 0;
+    try {
+      return page.url();
+    } catch {
+      console.warn(`${context}: failed to read page url`);
+      return void 0;
+    }
+  }
+  attachTrackers(managed) {
+    const activeTargetId = managed.targets.getActiveTargetId();
+    if (!activeTargetId) return;
+    const page = managed.targets.getActivePage();
+    managed.consoleTracker.attach(page);
+    managed.networkTracker.attach(page);
+  }
+  attachRefInvalidation(managed) {
+    const entries = managed.targets.listPageEntries();
+    for (const entry of entries) {
+      this.attachRefInvalidationForPage(managed, entry.targetId, entry.page);
+    }
+  }
+  attachRefInvalidationForPage(managed, targetId, page) {
+    if (this.pageListeners.has(page)) return;
+    const onNavigate = (frame) => {
+      if (frame.parentFrame() === null) {
+        managed.refStore.clearTarget(targetId);
+      }
+    };
+    const onClose = () => {
+      managed.refStore.clearTarget(targetId);
+    };
+    page.on("framenavigated", onNavigate);
+    page.on("close", onClose);
+    this.pageListeners.set(page, () => {
+      page.off("framenavigated", onNavigate);
+      page.off("close", onClose);
+    });
+  }
+  async resolveWsEndpoint(options) {
+    if (options.wsEndpoint) {
+      this.ensureLocalEndpoint(options.wsEndpoint);
+      return options.wsEndpoint;
+    }
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 9222;
+    const url = `http://${host}:${port}/json/version`;
+    this.ensureLocalEndpoint(url);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch CDP endpoint from ${url}`);
+    }
+    const data = await response.json();
+    if (!data.webSocketDebuggerUrl) {
+      throw new Error("webSocketDebuggerUrl missing from /json/version response");
+    }
+    this.ensureLocalEndpoint(data.webSocketDebuggerUrl);
+    return data.webSocketDebuggerUrl;
+  }
+  ensureLocalEndpoint(endpoint) {
+    if (this.config.security.allowNonLocalCdp) return;
+    const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["ws:", "wss:", "http:", "https:"]);
+    const LOCAL_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+    let parsed;
+    try {
+      parsed = new URL(endpoint);
+    } catch {
+      throw new Error("Invalid CDP endpoint URL.");
+    }
+    if (!ALLOWED_PROTOCOLS.has(parsed.protocol)) {
+      throw new Error(`Disallowed protocol "${parsed.protocol}" for CDP endpoint. Allowed: ws, wss, http, https.`);
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    if (!LOCAL_HOSTNAMES.has(hostname) && !hostname.toLowerCase().startsWith("::ffff:127.")) {
+      throw new Error("Non-local CDP endpoints are disabled by default.");
+    }
+  }
+  async connectWithEndpoint(wsEndpoint, mode) {
+    const browser = await chromium.connectOverCDP(wsEndpoint);
+    const contexts = browser.contexts();
+    const context = contexts[0] ?? await browser.newContext();
+    const sessionId = randomUUID3();
+    const targets = new TargetManager();
+    const pages = context.pages();
+    if (pages.length === 0) {
+      const page = await context.newPage();
+      targets.registerPage(page);
+    } else {
+      targets.registerExistingPages(pages);
+    }
+    const refStore = new RefStore();
+    const snapshotter = new Snapshotter(refStore);
+    const consoleTracker = new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole });
+    const networkTracker = new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls });
+    const managed = {
+      sessionId,
+      mode,
+      browser,
+      context,
+      profileDir: "",
+      persistProfile: true,
+      targets,
+      refStore,
+      snapshotter,
+      consoleTracker,
+      networkTracker
+    };
+    this.store.add({ id: sessionId, mode, browser, context });
+    this.sessions.set(sessionId, managed);
+    this.attachTrackers(managed);
+    this.attachRefInvalidation(managed);
+    return { sessionId, mode, activeTargetId: targets.getActiveTargetId(), warnings: [], wsEndpoint };
+  }
+};
+function truncateHtml(value, maxChars) {
+  if (value.length <= maxChars) {
+    return { outerHTML: value, truncated: false };
+  }
+  return { outerHTML: value.slice(0, maxChars), truncated: true };
+}
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars) {
+    return { text: value, truncated: false };
+  }
+  return { text: value.slice(0, maxChars), truncated: true };
+}
+
+// src/browser/script-runner.ts
+var ScriptRunner = class {
+  manager;
+  constructor(manager) {
+    this.manager = manager;
+  }
+  async run(sessionId, steps, stopOnError = true) {
+    const startTime = Date.now();
+    const results = [];
+    for (let i = 0; i < steps.length; i += 1) {
+      const step = steps[i];
+      if (!step) {
+        continue;
+      }
+      try {
+        const data = await this.executeStep(sessionId, step);
+        results.push({ i, ok: true, data });
+      } catch (error) {
+        results.push({
+          i,
+          ok: false,
+          error: { message: error instanceof Error ? error.message : "Unknown error" }
+        });
+        if (stopOnError) {
+          break;
+        }
+      }
+    }
+    return { results, timingMs: Date.now() - startTime };
+  }
+  async executeStep(sessionId, step) {
+    const args = step.args ?? {};
+    switch (step.action) {
+      case "goto":
+        return this.manager.goto(
+          sessionId,
+          requireString(args.url, "url"),
+          requireWaitUntil(args.waitUntil),
+          requireNumber(args.timeoutMs, 3e4)
+        );
+      case "wait":
+        if (typeof args.ref === "string") {
+          const ref = args.ref;
+          const state = requireState(args.state);
+          const timeoutMs = requireNumber(args.timeoutMs, 3e4);
+          return withRetry("wait", () => this.manager.waitForRef(
+            sessionId,
+            ref,
+            state,
+            timeoutMs
+          ));
+        }
+        return withRetry("wait", () => this.manager.waitForLoad(
+          sessionId,
+          requireWaitUntil(args.until),
+          requireNumber(args.timeoutMs, 3e4)
+        ));
+      case "snapshot":
+        return this.manager.snapshot(
+          sessionId,
+          requireSnapshotMode(args.format ?? args.mode),
+          requireNumber(args.maxChars, 16e3),
+          typeof args.cursor === "string" ? args.cursor : void 0
+        );
+      case "click":
+        return withRetry("click", () => this.manager.click(sessionId, requireString(args.ref, "ref")));
+      case "type":
+        return withRetry("type", () => this.manager.type(
+          sessionId,
+          requireString(args.ref, "ref"),
+          requireString(args.text, "text"),
+          Boolean(args.clear),
+          Boolean(args.submit)
+        ));
+      case "select":
+        return withRetry("select", () => this.manager.select(
+          sessionId,
+          requireString(args.ref, "ref"),
+          requireStringArray(args.values, "values")
+        ));
+      case "scroll":
+        return withRetry("scroll", () => this.manager.scroll(
+          sessionId,
+          requireNumber(args.dy, 0),
+          typeof args.ref === "string" ? args.ref : void 0
+        ));
+      case "dom_get_html":
+        return this.manager.domGetHtml(sessionId, requireString(args.ref, "ref"), requireNumber(args.maxChars, 8e3));
+      case "dom_get_text":
+        return this.manager.domGetText(sessionId, requireString(args.ref, "ref"), requireNumber(args.maxChars, 8e3));
+      default:
+        throw new Error(`Unknown action: ${step.action}`);
+    }
+  }
+};
+function requireString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Missing ${label}`);
+  }
+  return value;
+}
+function requireStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Invalid ${label}`);
+  }
+  return value;
+}
+function requireNumber(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return fallback;
+}
+function requireWaitUntil(value) {
+  if (value === "domcontentloaded" || value === "load" || value === "networkidle") {
+    return value;
+  }
+  return "load";
+}
+function requireSnapshotMode(value) {
+  if (value === "actionables") return "actionables";
+  return "outline";
+}
+function requireState(value) {
+  if (value === "visible" || value === "hidden") return value;
+  return "attached";
+}
+var RETRY_ACTIONS = /* @__PURE__ */ new Set(["click", "type", "select", "scroll", "wait"]);
+var RETRY_MAX_ATTEMPTS = 2;
+var RETRY_BASE_DELAY_MS = 150;
+var RETRY_MAX_DELAY_MS = 1e3;
+async function withRetry(action, fn) {
+  if (!RETRY_ACTIONS.has(action)) {
+    return fn();
+  }
+  let attempt = 0;
+  let delay = RETRY_BASE_DELAY_MS;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      attempt += 1;
+      if (attempt >= RETRY_MAX_ATTEMPTS || !shouldRetry(error)) {
+        throw error;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * 2, RETRY_MAX_DELAY_MS);
+    }
+  }
+}
+function shouldRetry(error) {
+  const message = error instanceof Error ? error.message : "";
+  if (!message) return true;
+  return !/missing|invalid|unknown ref|no active target/i.test(message);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/config.ts
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse as parseJsonc } from "jsonc-parser";
+
+// src/utils/crypto.ts
+import { randomBytes } from "crypto";
+function generateSecureToken() {
+  return randomBytes(32).toString("hex");
+}
+
+// src/config.ts
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_RELAY_PORT = 8787;
+function buildDefaultConfigJsonc(token) {
+  return `{
+  // Set relayToken to false to disable extension pairing.
+  "relayPort": ${DEFAULT_RELAY_PORT},
+  "relayToken": "${token}"
+}
+`;
+}
+var snapshotSchema = z.object({
+  maxChars: z.number().int().min(500).max(2e5).default(16e3),
+  maxNodes: z.number().int().min(50).max(5e3).default(1e3)
+});
+var securitySchema = z.object({
+  allowRawCDP: z.boolean().default(false),
+  allowNonLocalCdp: z.boolean().default(false),
+  allowUnsafeExport: z.boolean().default(false)
+});
+var devtoolsSchema = z.object({
+  showFullUrls: z.boolean().default(false),
+  showFullConsole: z.boolean().default(false)
+});
+var exportSchema = z.object({
+  maxNodes: z.number().int().min(1).max(5e3).default(1e3),
+  inlineStyles: z.boolean().default(true)
+});
+var skillsNudgeSchema = z.object({
+  enabled: z.boolean().default(true),
+  keywords: z.array(z.string()).default([
+    "login",
+    "sign in",
+    "sign-in",
+    "auth",
+    "authentication",
+    "mfa",
+    "form",
+    "submit",
+    "validation",
+    "extract",
+    "scrape",
+    "scraping",
+    "table",
+    "pagination",
+    "crawl"
+  ]),
+  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
+});
+var skillsSchema = z.object({
+  nudge: skillsNudgeSchema.default({})
+}).default({});
+var continuityNudgeSchema = z.object({
+  enabled: z.boolean().default(true),
+  keywords: z.array(z.string()).default([
+    "plan",
+    "multi-step",
+    "multi step",
+    "long-running",
+    "long running",
+    "refactor",
+    "migration",
+    "rollout",
+    "release",
+    "upgrade",
+    "investigate",
+    "follow-up",
+    "continue"
+  ]),
+  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
+});
+var continuitySchema = z.object({
+  enabled: z.boolean().default(true),
+  filePath: z.string().min(1).default("opendevbrowser_continuity.md"),
+  nudge: continuityNudgeSchema.default({})
+}).default({});
+var configSchema = z.object({
+  headless: z.boolean().default(false),
+  profile: z.string().min(1).default("default"),
+  snapshot: snapshotSchema.default({}),
+  security: securitySchema.default({}),
+  devtools: devtoolsSchema.default({}),
+  export: exportSchema.default({}),
+  skills: skillsSchema.default({}),
+  continuity: continuitySchema.default({}),
+  relayPort: z.number().int().min(0).max(65535).default(DEFAULT_RELAY_PORT),
+  relayToken: z.union([z.string(), z.literal(false)]).optional(),
+  chromePath: z.string().min(1).optional().refine(
+    (val) => val === void 0 || isExecutable(val),
+    { message: "chromePath must point to an executable file" }
+  ),
+  flags: z.array(z.string()).default([]),
+  checkForUpdates: z.boolean().default(false),
+  persistProfile: z.boolean().default(true),
+  skillPaths: z.array(z.string()).default([])
+});
+var CONFIG_FILE_NAME = "opendevbrowser.jsonc";
+function getGlobalConfigPath() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode");
+  return path.join(configDir, CONFIG_FILE_NAME);
+}
+function ensureConfigFile(filePath) {
+  const token = generateSecureToken();
+  if (fs.existsSync(filePath)) {
+    return token;
+  }
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+    fs.writeFileSync(filePath, buildDefaultConfigJsonc(token), { encoding: "utf-8", mode: 384 });
+  } catch (error) {
+    console.warn(`[opendevbrowser] Warning: Could not create config file at ${filePath}:`, error);
+  }
+  return token;
+}
+function loadConfigFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    const token = ensureConfigFile(filePath);
+    return { raw: {}, generatedToken: token };
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const errors = [];
+  const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    throw new Error(`Invalid JSONC in opendevbrowser config at ${filePath}: parse error at offset ${firstError.offset}`);
+  }
+  return { raw: parsed ?? {}, generatedToken: null };
+}
+function loadGlobalConfig() {
+  const configPath = getGlobalConfigPath();
+  const { raw, generatedToken } = loadConfigFile(configPath);
+  const parsed = configSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Invalid opendevbrowser config at ${configPath}: ${issues}`);
+  }
+  const data = parsed.data;
+  const relayToken = data.relayToken ?? generatedToken ?? generateSecureToken();
+  return { ...data, relayToken };
+}
+var ConfigStore = class {
+  current;
+  constructor(initial) {
+    this.current = initial;
+  }
+  get() {
+    return this.current;
+  }
+  set(next) {
+    this.current = next;
+  }
+};
+
+// src/relay/relay-server.ts
+import { createServer } from "http";
+import { timingSafeEqual } from "crypto";
+import { WebSocket, WebSocketServer } from "ws";
+var DEFAULT_DISCOVERY_PORT = 8787;
+var CONFIG_PATH = "/config";
+var PAIR_PATH = "/pair";
+var RelayServer = class _RelayServer {
+  running = false;
+  baseUrl = null;
+  port = null;
+  server = null;
+  discoveryServer = null;
+  extensionWss = null;
+  cdpWss = null;
+  extensionSocket = null;
+  cdpSocket = null;
+  extensionInfo = null;
+  pairingToken = null;
+  configuredDiscoveryPort;
+  discoveryPort = null;
+  handshakeAttempts = /* @__PURE__ */ new Map();
+  cdpAllowlist = null;
+  static MAX_HANDSHAKE_ATTEMPTS = 5;
+  static RATE_LIMIT_WINDOW_MS = 6e4;
+  constructor(options = {}) {
+    this.configuredDiscoveryPort = options.discoveryPort ?? DEFAULT_DISCOVERY_PORT;
+  }
+  async start(port = 8787) {
+    if (this.running && this.baseUrl && this.port !== null) {
+      return { url: this.baseUrl, port: this.port };
+    }
+    this.server = createServer();
+    this.extensionWss = new WebSocketServer({ noServer: true });
+    this.cdpWss = new WebSocketServer({ noServer: true });
+    this.extensionWss.on("connection", (socket) => {
+      if (this.extensionSocket) {
+        this.extensionSocket.close(1e3, "Replaced by a new extension client");
+      }
+      this.extensionSocket = socket;
+      this.extensionInfo = null;
+      socket.on("message", (data) => {
+        this.handleExtensionMessage(data);
+      });
+      socket.on("close", () => {
+        if (this.extensionSocket === socket) {
+          this.extensionSocket = null;
+          this.extensionInfo = null;
+        }
+        if (this.cdpSocket) {
+          this.cdpSocket.close(1011, "Extension disconnected");
+        }
+      });
+    });
+    this.cdpWss.on("connection", (socket) => {
+      if (this.cdpSocket) {
+        socket.close(1008, "Only one CDP client supported");
+        return;
+      }
+      this.cdpSocket = socket;
+      socket.on("message", (data) => {
+        this.handleCdpMessage(data);
+      });
+      socket.on("close", () => {
+        if (this.cdpSocket === socket) {
+          this.cdpSocket = null;
+        }
+      });
+    });
+    this.server.on("request", (request, response) => {
+      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
+      const origin = request.headers.origin;
+      if (pathname === CONFIG_PATH && request.method === "OPTIONS") {
+        this.handleConfigPreflight(origin, response);
+        return;
+      }
+      if (pathname === CONFIG_PATH && request.method === "GET") {
+        this.handleConfigRequest(origin, response);
+        return;
+      }
+      if (pathname === PAIR_PATH && request.method === "OPTIONS") {
+        if (origin && origin.startsWith("chrome-extension://")) {
+          response.setHeader("Access-Control-Allow-Origin", origin);
+          response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+          response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        }
+        response.writeHead(204);
+        response.end();
+        return;
+      }
+      if (pathname === PAIR_PATH && request.method === "GET") {
+        if (!this.isExtensionOrigin(origin)) {
+          response.writeHead(403, { "Content-Type": "application/json" });
+          response.end(JSON.stringify({ error: "Forbidden: extension origin required" }));
+          return;
+        }
+        response.setHeader("Access-Control-Allow-Origin", origin);
+        response.writeHead(200, { "Content-Type": "application/json" });
+        response.end(JSON.stringify({ token: this.pairingToken }));
+        return;
+      }
+      response.writeHead(404);
+      response.end();
+    });
+    this.server.on("upgrade", (request, socket, head) => {
+      const origin = request.headers.origin;
+      const ip = request.socket.remoteAddress ?? "unknown";
+      if (!this.isAllowedOrigin(origin)) {
+        this.logSecurityEvent("origin_blocked", { origin, ip });
+        socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+      if (this.isRateLimited(ip)) {
+        this.logSecurityEvent("rate_limited", { ip });
+        socket.write("HTTP/1.1 429 Too Many Requests\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
+      if (pathname === "/extension") {
+        this.extensionWss?.handleUpgrade(request, socket, head, (ws) => {
+          this.extensionWss?.emit("connection", ws, request);
+        });
+        return;
+      }
+      if (pathname === "/cdp") {
+        this.cdpWss?.handleUpgrade(request, socket, head, (ws) => {
+          this.cdpWss?.emit("connection", ws, request);
+        });
+        return;
+      }
+      socket.destroy();
+    });
+    await new Promise((resolve, reject) => {
+      this.server?.once("error", reject);
+      this.server?.listen(port, "127.0.0.1", () => {
+        resolve();
+      });
+    });
+    const address = this.server.address();
+    if (!address) {
+      throw new Error("Relay server did not expose a port");
+    }
+    this.port = address.port;
+    this.baseUrl = `ws://127.0.0.1:${address.port}`;
+    this.running = true;
+    try {
+      await this.startDiscoveryServer();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[opendevbrowser] Discovery server failed to start: ${message}`);
+      this.stopDiscoveryServer();
+    }
+    return { url: this.baseUrl, port: address.port };
+  }
+  stop() {
+    this.running = false;
+    this.baseUrl = null;
+    this.port = null;
+    this.extensionInfo = null;
+    this.stopDiscoveryServer();
+    if (this.extensionSocket) {
+      this.extensionSocket.close(1e3, "Relay stopped");
+      this.extensionSocket = null;
+    }
+    if (this.cdpSocket) {
+      this.cdpSocket.close(1e3, "Relay stopped");
+      this.cdpSocket = null;
+    }
+    this.extensionWss?.close();
+    this.cdpWss?.close();
+    this.server?.close();
+    this.extensionWss = null;
+    this.cdpWss = null;
+    this.server = null;
+  }
+  status() {
+    return {
+      running: this.running,
+      url: this.baseUrl || void 0,
+      port: this.port ?? void 0,
+      extensionConnected: Boolean(this.extensionSocket),
+      cdpConnected: Boolean(this.cdpSocket),
+      extension: this.extensionInfo ?? void 0
+    };
+  }
+  getCdpUrl() {
+    return this.baseUrl ? `${this.baseUrl}/cdp` : null;
+  }
+  getDiscoveryPort() {
+    if (this.port !== null && this.port === this.configuredDiscoveryPort) {
+      return this.port;
+    }
+    return this.discoveryPort;
+  }
+  setToken(token) {
+    const trimmed = typeof token === "string" ? token.trim() : "";
+    this.pairingToken = trimmed.length ? trimmed : null;
+  }
+  setCdpAllowlist(methods) {
+    if (!methods || methods.length === 0) {
+      this.cdpAllowlist = null;
+      return;
+    }
+    this.cdpAllowlist = new Set(methods);
+  }
+  isAllowedOrigin(origin) {
+    if (!origin) {
+      return true;
+    }
+    if (origin.startsWith("chrome-extension://")) {
+      return true;
+    }
+    return false;
+  }
+  isExtensionOrigin(origin) {
+    return Boolean(origin && origin.startsWith("chrome-extension://"));
+  }
+  handleConfigPreflight(origin, response) {
+    if (this.isExtensionOrigin(origin)) {
+      response.setHeader("Access-Control-Allow-Origin", origin);
+      response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    }
+    response.writeHead(204);
+    response.end();
+  }
+  handleConfigRequest(origin, response) {
+    if (!this.isExtensionOrigin(origin)) {
+      response.writeHead(403, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "Forbidden: extension origin required" }));
+      return;
+    }
+    if (origin) {
+      response.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    if (this.port === null) {
+      response.writeHead(503, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "Relay not running" }));
+      return;
+    }
+    response.writeHead(200, {
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store"
+    });
+    response.end(JSON.stringify({
+      relayPort: this.port,
+      pairingRequired: Boolean(this.pairingToken)
+    }));
+  }
+  async startDiscoveryServer() {
+    if (this.port === null || this.discoveryServer) {
+      return;
+    }
+    if (this.configuredDiscoveryPort > 0 && this.configuredDiscoveryPort === this.port) {
+      return;
+    }
+    this.discoveryServer = createServer((request, response) => {
+      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
+      const origin = request.headers.origin;
+      if (pathname === CONFIG_PATH && request.method === "OPTIONS") {
+        this.handleConfigPreflight(origin, response);
+        return;
+      }
+      if (pathname === CONFIG_PATH && request.method === "GET") {
+        this.handleConfigRequest(origin, response);
+        return;
+      }
+      response.writeHead(404);
+      response.end();
+    });
+    await new Promise((resolve, reject) => {
+      this.discoveryServer?.once("error", reject);
+      this.discoveryServer?.listen(this.configuredDiscoveryPort, "127.0.0.1", () => {
+        resolve();
+      });
+    });
+    const address = this.discoveryServer.address();
+    if (!address) {
+      throw new Error("Discovery server did not expose a port");
+    }
+    this.discoveryPort = address.port;
+  }
+  stopDiscoveryServer() {
+    if (this.discoveryServer) {
+      this.discoveryServer.close();
+      this.discoveryServer = null;
+    }
+    this.discoveryPort = null;
+  }
+  isRateLimited(ip) {
+    const now = Date.now();
+    const record = this.handshakeAttempts.get(ip);
+    if (!record || now > record.resetAt) {
+      this.handshakeAttempts.set(ip, { count: 1, resetAt: now + _RelayServer.RATE_LIMIT_WINDOW_MS });
+      return false;
+    }
+    record.count++;
+    return record.count > _RelayServer.MAX_HANDSHAKE_ATTEMPTS;
+  }
+  isCommandAllowed(method) {
+    if (!this.cdpAllowlist) return true;
+    return this.cdpAllowlist.has(method);
+  }
+  logSecurityEvent(event, details) {
+    const safeDetails = { ...details };
+    delete safeDetails.token;
+    delete safeDetails.pairingToken;
+    console.warn(`[security] ${event}`, JSON.stringify(safeDetails));
+  }
+  handleCdpMessage(data) {
+    const message = parseJson(data);
+    if (!isRecord(message)) {
+      return;
+    }
+    const id = message.id;
+    const method = message.method;
+    if (typeof id !== "string" && typeof id !== "number" || typeof method !== "string") {
+      return;
+    }
+    if (!this.extensionSocket) {
+      this.sendJson(this.cdpSocket, {
+        id,
+        error: { message: "Extension not connected to relay" }
+      });
+      return;
+    }
+    if (!this.isCommandAllowed(method)) {
+      this.logSecurityEvent("command_blocked", { method });
+      this.sendJson(this.cdpSocket, {
+        id,
+        error: { message: `CDP command '${method}' not in allowlist` }
+      });
+      return;
+    }
+    const relayCommand = {
+      id,
+      method: "forwardCDPCommand",
+      params: {
+        method,
+        params: message.params,
+        sessionId: typeof message.sessionId === "string" ? message.sessionId : void 0
+      }
+    };
+    this.sendJson(this.extensionSocket, relayCommand);
+  }
+  handleExtensionMessage(data) {
+    const message = parseJson(data);
+    if (!isRecord(message)) {
+      return;
+    }
+    if (isHandshake(message)) {
+      if (!this.isPairingTokenValid(message)) {
+        this.logSecurityEvent("handshake_failed", { reason: "invalid_token", tabId: message.payload.tabId });
+        this.extensionInfo = null;
+        this.extensionSocket?.close(1008, "Invalid pairing token");
+        return;
+      }
+      this.extensionInfo = {
+        tabId: message.payload.tabId,
+        url: message.payload.url,
+        title: message.payload.title,
+        groupId: message.payload.groupId
+      };
+      return;
+    }
+    if (message.method === "forwardCDPEvent" && isRecord(message.params)) {
+      const params = message.params;
+      const event = {
+        method: params.method,
+        params: params.params ?? {}
+      };
+      if (params.sessionId) {
+        event.sessionId = params.sessionId;
+      }
+      this.sendJson(this.cdpSocket, event);
+      return;
+    }
+    if (typeof message.id === "string" || typeof message.id === "number") {
+      const response = { id: message.id };
+      if (typeof message.result !== "undefined") {
+        response.result = message.result;
+      }
+      if (message.error) {
+        response.error = message.error;
+      }
+      if (typeof message.sessionId === "string") {
+        response.sessionId = message.sessionId;
+      }
+      this.sendJson(this.cdpSocket, response);
+    }
+  }
+  sendJson(socket, payload) {
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    socket.send(JSON.stringify(payload));
+  }
+  isPairingTokenValid(handshake) {
+    if (!this.pairingToken) {
+      return true;
+    }
+    const expected = this.pairingToken;
+    const received = handshake.payload.pairingToken ?? "";
+    const expectedBuf = Buffer.from(expected, "utf-8");
+    const receivedBuf = Buffer.from(received, "utf-8");
+    if (expectedBuf.length !== receivedBuf.length) {
+      timingSafeEqual(expectedBuf, expectedBuf);
+      return false;
+    }
+    return timingSafeEqual(expectedBuf, receivedBuf);
+  }
+};
+var parseJson = (data) => {
+  const text = typeof data === "string" ? data : data.toString();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null;
+};
+var isHandshake = (value) => {
+  if (value.type !== "handshake" || !isRecord(value.payload)) {
+    return false;
+  }
+  return typeof value.payload.tabId === "number";
+};
+
+// src/skills/skill-loader.ts
+import { readFile, readdir } from "fs/promises";
+import { join as join6 } from "path";
+import * as os2 from "os";
+var SkillLoader = class {
+  rootDir;
+  additionalPaths;
+  skillCache = null;
+  constructor(rootDir, additionalPaths = []) {
+    this.rootDir = rootDir;
+    this.additionalPaths = additionalPaths.map((p) => this.expandPath(p));
+  }
+  expandPath(p) {
+    if (p.startsWith("~")) {
+      return join6(os2.homedir(), p.slice(1));
+    }
+    return p;
+  }
+  async loadBestPractices(topic) {
+    return this.loadSkill("opendevbrowser-best-practices", topic);
+  }
+  async loadSkill(name, topic) {
+    const skills = await this.listSkills();
+    const skill = skills.find((s) => s.name === name);
+    if (!skill) {
+      const available = skills.map((s) => s.name).join(", ") || "none";
+      throw new Error(`Skill "${name}" not found. Available: ${available}`);
+    }
+    const content = await readFile(skill.path, "utf8");
+    const trimmed = content.trim();
+    if (!topic || !topic.trim()) {
+      return trimmed;
+    }
+    const filtered = filterSections(trimmed, topic);
+    return filtered || trimmed;
+  }
+  async listSkills() {
+    if (this.skillCache) {
+      return this.skillCache;
+    }
+    const skills = [];
+    const searchPaths = this.getSearchPaths();
+    for (const searchPath of searchPaths) {
+      const discovered = await this.discoverSkillsInPath(searchPath);
+      for (const skill of discovered) {
+        if (!skills.some((s) => s.name === skill.name)) {
+          skills.push(skill);
+        }
+      }
+    }
+    this.skillCache = skills;
+    return skills;
+  }
+  getSearchPaths() {
+    const configDir = process.env.OPENCODE_CONFIG_DIR || join6(os2.homedir(), ".config", "opencode");
+    const searchPaths = [
+      join6(this.rootDir, ".opencode", "skill"),
+      join6(configDir, "skill"),
+      join6(this.rootDir, ".claude", "skills"),
+      join6(os2.homedir(), ".claude", "skills"),
+      ...this.additionalPaths
+    ];
+    return Array.from(new Set(searchPaths));
+  }
+  async discoverSkillsInPath(searchPath) {
+    const skills = [];
+    try {
+      const entries = await readdir(searchPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillPath = join6(searchPath, entry.name, "SKILL.md");
+        try {
+          const content = await readFile(skillPath, "utf8");
+          const metadata = this.parseSkillMetadata(content, entry.name);
+          skills.push({
+            name: metadata.name,
+            description: metadata.description,
+            version: metadata.version ?? "1.0.0",
+            path: skillPath
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return skills;
+  }
+  parseSkillMetadata(content, dirName) {
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return {
+        name: dirName,
+        description: this.extractFirstParagraph(content) || `Skill: ${dirName}`
+      };
+    }
+    const frontmatter = frontmatterMatch[1] ?? "";
+    const metadata = {
+      name: dirName,
+      description: ""
+    };
+    const nameMatch = frontmatter.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
+    if (nameMatch?.[1]) {
+      metadata.name = nameMatch[1].trim();
+    }
+    const descMatch = frontmatter.match(/^description:\s*["']?([^"'\n]+)["']?\s*$/m);
+    if (descMatch?.[1]) {
+      metadata.description = descMatch[1].trim();
+    }
+    const versionMatch = frontmatter.match(/^version:\s*["']?([^"'\n]+)["']?\s*$/m);
+    if (versionMatch?.[1]) {
+      metadata.version = versionMatch[1].trim();
+    }
+    if (!metadata.description) {
+      const afterFrontmatter = content.slice(frontmatterMatch[0].length);
+      metadata.description = this.extractFirstParagraph(afterFrontmatter) || `Skill: ${metadata.name}`;
+    }
+    return metadata;
+  }
+  extractFirstParagraph(content) {
+    const lines = content.trim().split(/\n/);
+    const paragraphLines = [];
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith("#")) continue;
+      if (trimmedLine === "" && paragraphLines.length > 0) break;
+      if (trimmedLine !== "") {
+        paragraphLines.push(trimmedLine);
+      }
+    }
+    const paragraph = paragraphLines.join(" ").trim();
+    return paragraph.length > 0 ? paragraph.slice(0, 200) : null;
+  }
+  clearCache() {
+    this.skillCache = null;
+  }
+};
+function filterSections(content, topic) {
+  const normalized = topic.trim().toLowerCase();
+  const lines = content.split(/\r?\n/);
+  const sections = [];
+  let currentHeading = "";
+  let currentBody = [];
+  const flush = () => {
+    if (currentHeading || currentBody.length > 0) {
+      sections.push({ heading: currentHeading, body: [...currentBody] });
+    }
+    currentHeading = "";
+    currentBody = [];
+  };
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,3})\s+(.*)$/);
+    if (headingMatch) {
+      flush();
+      currentHeading = headingMatch[2]?.trim() ?? "";
+      currentBody.push(line);
+      continue;
+    }
+    currentBody.push(line);
+  }
+  flush();
+  const matches = sections.filter((section) => section.heading.toLowerCase().includes(normalized));
+  if (matches.length === 0) {
+    return null;
+  }
+  return matches.map((section) => section.body.join("\n")).join("\n\n");
+}
+
+// src/core/bootstrap.ts
+function createOpenDevBrowserCore(options) {
+  const config = options.config ?? loadGlobalConfig();
+  const configStore = new ConfigStore(config);
+  const cacheRoot = options.worktree ?? options.directory;
+  const manager = new BrowserManager(cacheRoot, config);
+  const runner = new ScriptRunner(manager);
+  const skills = new SkillLoader(cacheRoot, config.skillPaths);
+  const relay = new RelayServer();
+  relay.setToken(config.relayToken);
+  const ensureRelay = async (port = config.relayPort) => {
+    if (port <= 0 || config.relayToken === false) {
+      relay.stop();
+      return;
+    }
+    const status = relay.status();
+    if (status.running && status.port === port) {
+      return;
+    }
+    relay.stop();
+    try {
+      await relay.start(port);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("EADDRINUSE") || message.includes("in use")) {
+        console.warn(`[opendevbrowser] Relay server port ${port} is already in use. Extension pairing will be unavailable.`);
+        console.warn(`[opendevbrowser] To fix: kill the process using port ${port} or change relayPort in config.`);
+      } else {
+        console.warn(`[opendevbrowser] Failed to start relay server: ${message}`);
+      }
+    }
+  };
+  const cleanup = () => {
+    relay.stop();
+    manager.closeAll().catch(() => {
+    });
+  };
+  return {
+    cacheRoot,
+    config,
+    configStore,
+    manager,
+    runner,
+    skills,
+    relay,
+    ensureRelay,
+    cleanup,
+    getExtensionPath
+  };
+}
+
+export {
+  generateSecureToken,
+  loadGlobalConfig,
+  extractExtension,
+  createOpenDevBrowserCore
+};
+/* v8 ignore next -- @preserve */
+//# sourceMappingURL=chunk-WTFSMBVH.js.map