browsirai 0.1.1 → 0.2.1

package/dist/cli/commands/obs.js

@@ -0,0 +1,1049 @@
+// src/cli/commands/obs.ts
+import { writeFileSync } from "fs";
+
+// src/cli/run.ts
+import pc from "picocolors";
+
+// src/chrome-launcher.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import http from "http";
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createConnection } from "net";
+
+// src/cli/run.ts
+function parseFlags(args) {
+  const flags = {};
+  let positionalIndex = 0;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = "true";
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1 && !/^-\d/.test(arg)) {
+      const chars = arg.slice(1);
+      if (chars.length === 1) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[chars] = next;
+          i++;
+        } else {
+          flags[chars] = "true";
+        }
+      } else {
+        for (const ch of chars) {
+          flags[ch] = "true";
+        }
+      }
+    } else {
+      flags[`_${positionalIndex}`] = arg;
+      positionalIndex++;
+    }
+  }
+  return flags;
+}
+
+// src/tools/browser-snapshot.ts
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "searchbox",
+  "slider",
+  "spinbutton",
+  "switch",
+  "tab",
+  "treeitem"
+]);
+function shouldShowAxNode(node, options) {
+  const role = node.role?.value ?? "";
+  if (role === "none") {
+    return false;
+  }
+  if (role === "generic") {
+    const name2 = node.name?.value ?? "";
+    if (!name2) {
+      return false;
+    }
+  }
+  if (options?.compact && role === "InlineTextBox") {
+    return false;
+  }
+  const name = node.name?.value ?? "";
+  const value = node.value?.value ?? null;
+  if (!name && (value === null || value === void 0 || value === "")) {
+    return false;
+  }
+  return true;
+}
+function getChildNodeIds(node) {
+  if (node.childIds && node.childIds.length > 0) {
+    return node.childIds;
+  }
+  if (node.children && node.children.length > 0) {
+    return node.children.map((c) => c.nodeId);
+  }
+  return [];
+}
+function formatNodeAttributes(node) {
+  const parts = [];
+  if (node.value?.value !== void 0 && node.value.value !== "") {
+    parts.push(`value="${node.value.value}"`);
+  }
+  if (node.description?.value) {
+    parts.push(`description="${node.description.value}"`);
+  }
+  if (node.properties) {
+    for (const prop of node.properties) {
+      switch (prop.name) {
+        case "level":
+          parts.push(`level=${prop.value.value}`);
+          break;
+        case "checked": {
+          const val = prop.value.value;
+          if (val === true || val === "true" || val === "mixed") {
+            parts.push("checked");
+          }
+          break;
+        }
+        case "selected":
+          if (prop.value.value === true) {
+            parts.push("selected");
+          }
+          break;
+        case "expanded":
+          if (prop.value.value === true || prop.value.value === "true") {
+            parts.push("expanded");
+          } else {
+            parts.push("collapsed");
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return parts.join(" ");
+}
+async function browserSnapshot(cdp, params) {
+  const options = {
+    interactive: params?.interactive,
+    cursor: params?.cursor,
+    compact: params?.compact,
+    depth: params?.depth,
+    selector: params?.selector
+  };
+  await cdp.send("Accessibility.enable");
+  let axNodes;
+  if (options.selector) {
+    const docResult = await cdp.send("DOM.getDocument");
+    const queryResult = await cdp.send("DOM.querySelector", {
+      nodeId: docResult.root.nodeId,
+      selector: options.selector
+    });
+    if (queryResult.nodeId === 0) {
+      return { snapshot: `No element found for selector: ${options.selector}` };
+    }
+    const partialResult = await cdp.send("Accessibility.getPartialAXTree", {
+      nodeId: queryResult.nodeId,
+      fetchRelatives: true
+    });
+    axNodes = partialResult.nodes;
+  } else {
+    const fullResult = await cdp.send("Accessibility.getFullAXTree");
+    axNodes = fullResult.nodes;
+  }
+  const totalElements = axNodes.filter(
+    (n) => n.role?.value !== "WebArea"
+  ).length;
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of axNodes) {
+    nodeMap.set(node.nodeId, node);
+  }
+  let root;
+  for (const node of axNodes) {
+    if (!node.parentId) {
+      root = node;
+      break;
+    }
+  }
+  if (!root) {
+    root = axNodes[0];
+  }
+  if (!root) {
+    return { snapshot: "" };
+  }
+  const lines = [];
+  let refCounter = 0;
+  const visited = /* @__PURE__ */ new Set();
+  const maxDepth = options.depth ?? 100;
+  function traverse(node, depth) {
+    if (visited.has(node.nodeId)) {
+      return;
+    }
+    visited.add(node.nodeId);
+    if (depth > maxDepth) {
+      return;
+    }
+    const role = node.role?.value ?? "";
+    const isRoot = role === "WebArea";
+    const showNode = isRoot || shouldShow(node, options);
+    if (showNode && !isRoot) {
+      refCounter++;
+      const ref = node.backendDOMNodeId ? `@e${node.backendDOMNodeId}` : `@e${refCounter}`;
+      const indent = "  ".repeat(depth);
+      const name = node.name?.value ?? "";
+      const attrs = formatNodeAttributes(node);
+      let line = `${indent}${ref} ${role}`;
+      if (name) {
+        line += ` "${name}"`;
+      }
+      if (attrs) {
+        line += ` ${attrs}`;
+      }
+      lines.push(line);
+    }
+    const childNodeIds = getChildNodeIds(node);
+    const nextDepth = isRoot ? depth : depth + 1;
+    for (const childId of childNodeIds) {
+      const childNode = nodeMap.get(childId);
+      if (childNode) {
+        traverse(childNode, nextDepth);
+      }
+    }
+  }
+  traverse(root, 0);
+  const snapshot = lines.join("\n");
+  const result = { snapshot };
+  if (totalElements > 1e3) {
+    result.truncated = true;
+    result.totalElements = totalElements;
+  }
+  return result;
+}
+function shouldShow(node, options) {
+  if (!shouldShowAxNode(node, { compact: options.compact })) {
+    return false;
+  }
+  const role = node.role?.value ?? "";
+  if (options.interactive) {
+    if (INTERACTIVE_ROLES.has(role)) {
+      return true;
+    }
+    if (options.cursor) {
+      return hasCursorPointer(node);
+    }
+    return false;
+  }
+  if (options.cursor) {
+    if (hasCursorPointer(node)) {
+      return true;
+    }
+  }
+  return true;
+}
+function hasCursorPointer(node) {
+  if (!node.properties) return false;
+  return node.properties.some(
+    (p) => p.name === "cursor" && p.value.value === "pointer"
+  );
+}
+
+// src/tools/browser-screenshot.ts
+async function detectDPR(cdp) {
+  try {
+    const metrics = await cdp.send("Page.getLayoutMetrics", {});
+    if (metrics.visualViewport && metrics.cssVisualViewport) {
+      const physicalWidth = metrics.visualViewport.clientWidth;
+      const cssWidth = metrics.cssVisualViewport.clientWidth;
+      if (cssWidth > 0 && physicalWidth > 0) {
+        const dpr = physicalWidth / cssWidth;
+        if (dpr >= 1) {
+          return dpr;
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: "window.devicePixelRatio",
+      returnByValue: true
+    });
+    if (evalResult.result.type === "number" && typeof evalResult.result.value === "number") {
+      return evalResult.result.value;
+    }
+  } catch {
+  }
+  return 1;
+}
+async function getElementBoxBySelector(cdp, selector) {
+  const doc = await cdp.send("DOM.getDocument", {});
+  const queryResult = await cdp.send("DOM.querySelector", {
+    nodeId: doc.root.nodeId,
+    selector
+  });
+  if (!queryResult.nodeId) {
+    throw new Error(`Element not found: ${selector}`);
+  }
+  const boxModel = await cdp.send("DOM.getBoxModel", {
+    nodeId: queryResult.nodeId
+  });
+  const content = boxModel.model.content;
+  const x = content[0];
+  const y = content[1];
+  const width = content[2] - content[0];
+  const height = content[5] - content[1];
+  return { x, y, width, height };
+}
+async function getElementBoxByRef(cdp, ref) {
+  const match = /^@e(\d+)$/.exec(ref);
+  if (!match) {
+    throw new Error(`Invalid ref format: ${ref}`);
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const boxModel = await cdp.send("DOM.getBoxModel", {
+    backendNodeId
+  });
+  const content = boxModel.model.content;
+  const x = content[0];
+  const y = content[1];
+  const width = content[2] - content[0];
+  const height = content[5] - content[1];
+  return { x, y, width, height };
+}
+async function buildAnnotations(cdp) {
+  const axTree = await cdp.send("Accessibility.getFullAXTree", {}, { timeout: 1e4 });
+  const annotations = [];
+  let counter = 0;
+  for (const node of axTree.nodes) {
+    const role = node.role?.value;
+    if (role === "WebArea") {
+      continue;
+    }
+    counter++;
+    const ref = node.backendDOMNodeId ? `@e${node.backendDOMNodeId}` : `@e${counter}`;
+    const label = `[${counter}]`;
+    annotations.push({
+      ref,
+      label,
+      role: role ?? "unknown",
+      name: node.name?.value ?? ""
+    });
+  }
+  return annotations;
+}
+async function browserScreenshot(cdp, params) {
+  const format = params.format ?? "png";
+  const captureParams = {
+    format
+  };
+  if (format === "jpeg" && params.quality !== void 0) {
+    captureParams.quality = params.quality;
+  }
+  const _dpr = await detectDPR(cdp);
+  if (params.selector) {
+    const box = await getElementBoxBySelector(cdp, params.selector);
+    captureParams.clip = {
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      scale: 1
+    };
+  }
+  if (params.ref) {
+    const box = await getElementBoxByRef(cdp, params.ref);
+    captureParams.clip = {
+      x: box.x,
+      y: box.y,
+      width: box.width,
+      height: box.height,
+      scale: 1
+    };
+  }
+  if (params.fullPage) {
+    const metrics = await cdp.send("Page.getLayoutMetrics", {});
+    const contentWidth = metrics.cssContentSize?.width ?? metrics.contentSize.width;
+    const contentHeight = metrics.cssContentSize?.height ?? metrics.contentSize.height;
+    captureParams.clip = {
+      x: 0,
+      y: 0,
+      width: contentWidth,
+      height: contentHeight,
+      scale: 1
+    };
+  }
+  const screenshot = await cdp.send("Page.captureScreenshot", captureParams);
+  const result = {
+    base64: screenshot.data
+  };
+  if (params.annotate) {
+    result.annotations = await buildAnnotations(cdp);
+  }
+  return result;
+}
+
+// src/tools/browser-html.ts
+async function browserHtml(cdp, params) {
+  if (!params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: "document.documentElement.outerHTML",
+      returnByValue: true
+    });
+    return { html: evalResult.result.value };
+  }
+  const doc = await cdp.send("DOM.getDocument", {});
+  const queryResult = await cdp.send("DOM.querySelector", {
+    nodeId: doc.root.nodeId,
+    selector: params.selector
+  });
+  if (!queryResult.nodeId) {
+    return {
+      html: "",
+      error: `Element not found: ${params.selector}`
+    };
+  }
+  const outerResult = await cdp.send("DOM.getOuterHTML", {
+    nodeId: queryResult.nodeId
+  });
+  return { html: outerResult.outerHTML };
+}
+
+// src/tools/browser-eval.ts
+function parseRemoteObject(obj) {
+  if (obj.type === "undefined") {
+    return void 0;
+  }
+  if (obj.type === "object" && obj.subtype === "null") {
+    return null;
+  }
+  if (obj.type === "object" && obj.subtype === "node") {
+    return obj.description ?? `[${obj.className ?? "Node"}]`;
+  }
+  if (obj.value !== void 0) {
+    return obj.value;
+  }
+  if (obj.description) {
+    return obj.description;
+  }
+  return void 0;
+}
+function formatException(details) {
+  if (details.exception?.description) {
+    return details.exception.description;
+  }
+  if (details.exception?.className) {
+    return `${details.exception.className}: ${details.text}`;
+  }
+  return details.text;
+}
+async function browserEval(cdp, params) {
+  let expression = params.expression;
+  if (params.base64) {
+    expression = atob(expression);
+  }
+  if (params.ref) {
+    return evalWithRef(cdp, expression, params.ref);
+  }
+  return evalGlobal(cdp, expression);
+}
+async function evalGlobal(cdp, expression) {
+  const response = await cdp.send("Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (response.exceptionDetails) {
+    return {
+      error: formatException(response.exceptionDetails)
+    };
+  }
+  const value = parseRemoteObject(response.result);
+  return { result: value };
+}
+async function evalWithRef(cdp, functionDeclaration, ref) {
+  const match = /^@e(\d+)$/.exec(ref);
+  if (!match) {
+    return { error: `Invalid ref format: ${ref}` };
+  }
+  const backendNodeId = parseInt(match[1], 10);
+  const resolved = await cdp.send("DOM.resolveNode", {
+    backendNodeId
+  });
+  const objectId = resolved.object.objectId;
+  const response = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (response.exceptionDetails) {
+    return {
+      error: formatException(response.exceptionDetails)
+    };
+  }
+  const value = parseRemoteObject(response.result);
+  return { result: value };
+}
+
+// src/tools/browser-find.ts
+async function browserFind(cdp, params) {
+  const nth = params.nth ?? 0;
+  const response = await cdp.send("Accessibility.getFullAXTree", void 0, {
+    timeout: 1e4
+  });
+  const matches = response.nodes.filter((node) => {
+    if (params.role) {
+      const nodeRole = node.role?.value ?? "";
+      if (nodeRole.toLowerCase() !== params.role.toLowerCase()) {
+        return false;
+      }
+    }
+    if (params.name) {
+      const nodeName = node.name?.value ?? "";
+      if (!nodeName.includes(params.name)) {
+        return false;
+      }
+    }
+    if (params.text) {
+      const nodeName = node.name?.value ?? "";
+      if (!nodeName.includes(params.text)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  const count = matches.length;
+  if (nth >= count || count === 0) {
+    return {
+      found: false,
+      ref: null,
+      role: null,
+      name: null,
+      count
+    };
+  }
+  const match = matches[nth];
+  const ref = match.backendDOMNodeId ? `@e${match.backendDOMNodeId}` : null;
+  return {
+    found: true,
+    ref,
+    role: match.role?.value ?? null,
+    name: match.name?.value ?? null,
+    count
+  };
+}
+
+// src/tools/browser-inspect-source.ts
+var REF_PATTERN = /^@?e(\d+)$/;
+async function browserInspectSource(cdp, params) {
+  let objectId;
+  if (params.ref) {
+    const match = REF_PATTERN.exec(params.ref);
+    if (!match) throw new Error(`Invalid ref format: ${params.ref}`);
+    const backendNodeId = parseInt(match[1], 10);
+    const resolved = await cdp.send("DOM.resolveNode", { backendNodeId });
+    objectId = resolved.object.objectId;
+  } else if (params.selector) {
+    const evalResult = await cdp.send("Runtime.evaluate", {
+      expression: `document.querySelector(${JSON.stringify(params.selector)})`,
+      returnByValue: false
+    });
+    if (!evalResult.result.objectId || evalResult.result.subtype === "null") {
+      throw new Error(`Element not found: ${params.selector}`);
+    }
+    objectId = evalResult.result.objectId;
+  } else {
+    throw new Error("Either ref or selector must be provided");
+  }
+  const cdpResult = await cdp.send("Runtime.callFunctionOn", {
+    objectId,
+    functionDeclaration: `function() {
+      var el = this;
+      var tagName = (el.tagName || '').toLowerCase();
+
+      // Find React Fiber
+      var fiberKey = Object.keys(el).find(function(k) { return k.startsWith('__reactFiber'); });
+
+      // Also check Vue, Svelte
+      var vueComp = el.__vueParentComponent;
+      var svelteMeta = el.__svelte_meta;
+
+      if (!fiberKey && !vueComp && !svelteMeta) {
+        return JSON.stringify({ tagName: tagName, componentName: null, source: null, stack: [], framework: null });
+      }
+
+      // --- React path ---
+      if (fiberKey) {
+        var fiber = el[fiberKey];
+        var stack = [];
+        var current = fiber;
+        var firstSource = null;
+        var firstName = null;
+
+        while (current && stack.length < 15) {
+          if (typeof current.type === 'function' && current.type.name) {
+            var fn = current.type;
+            var fnStr = fn.toString();
+            var fileName = null;
+            var lineNumber = null;
+            var columnNumber = null;
+
+            // Parse jsxDEV calls for embedded fileName/lineNumber
+            var fileMatch = fnStr.match(/fileName:\\s*"([^"]+)"/);
+            if (fileMatch) {
+              fileName = fileMatch[1];
+              var lineMatch = fnStr.match(/lineNumber:\\s*(\\d+)/);
+              if (lineMatch) lineNumber = parseInt(lineMatch[1]);
+              var colMatch = fnStr.match(/columnNumber:\\s*(\\d+)/);
+              if (colMatch) columnNumber = parseInt(colMatch[1]);
+            }
+
+            var entry = {
+              filePath: fileName,
+              lineNumber: lineNumber,
+              columnNumber: columnNumber,
+              componentName: fn.name
+            };
+
+            stack.push(entry);
+
+            if (fileName && !firstSource) {
+              firstSource = entry;
+            }
+            if (!firstName && fn.name.length > 1) {
+              firstName = fn.name;
+            }
+          }
+          current = current.return;
+        }
+
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: firstName || null,
+          source: firstSource || (stack.length > 0 ? { filePath: null, lineNumber: null, columnNumber: null, componentName: stack[0].componentName } : null),
+          stack: stack.filter(function(s) { return s.filePath; }),
+          framework: 'react'
+        });
+      }
+
+      // --- Svelte path ---
+      if (svelteMeta) {
+        var loc = svelteMeta.loc || {};
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: loc.char ? null : (svelteMeta.component || null),
+          source: loc.file ? { filePath: loc.file, lineNumber: loc.line || null, columnNumber: (loc.column || 0) + 1, componentName: null } : null,
+          stack: [],
+          framework: 'svelte'
+        });
+      }
+
+      // --- Vue path ---
+      if (vueComp) {
+        var comp = vueComp;
+        var vueName = comp.type?.__name || comp.type?.name || null;
+        var vueFile = comp.type?.__file || null;
+        return JSON.stringify({
+          tagName: tagName,
+          componentName: vueName,
+          source: vueFile ? { filePath: vueFile, lineNumber: null, columnNumber: null, componentName: vueName } : null,
+          stack: [],
+          framework: 'vue'
+        });
+      }
+
+      return JSON.stringify({ tagName: tagName, componentName: null, source: null, stack: [], framework: null });
+    }`,
+    returnByValue: true
+  });
+  return JSON.parse(cdpResult.result.value);
+}
+
+// src/event-buffer.ts
+var EventBuffer = class {
+  _buffer;
+  _capacity;
+  _head;
+  // next write index
+  _size;
+  _totalPushed;
+  constructor(capacity = 500) {
+    this._capacity = capacity;
+    this._buffer = new Array(capacity);
+    this._head = 0;
+    this._size = 0;
+    this._totalPushed = 0;
+  }
+  /** Append an event, evicting the oldest if at capacity. */
+  push(event) {
+    this._buffer[this._head] = event;
+    this._head = (this._head + 1) % this._capacity;
+    if (this._size < this._capacity) {
+      this._size++;
+    }
+    this._totalPushed++;
+  }
+  /**
+   * Return the last `n` events in chronological (oldest-first) order.
+   * Defaults to all events when `n` is omitted.
+   */
+  last(n) {
+    const count = n === void 0 ? this._size : Math.min(n, this._size);
+    if (count === 0) return [];
+    const result = new Array(count);
+    let start = (this._head - count + this._capacity) % this._capacity;
+    for (let i = 0; i < count; i++) {
+      result[i] = this._buffer[(start + i) % this._capacity];
+    }
+    return result;
+  }
+  /** Remove all events from the buffer. */
+  clear() {
+    this._buffer = new Array(this._capacity);
+    this._head = 0;
+    this._size = 0;
+  }
+  /**
+   * Return the last `n` events AND remove them from the buffer.
+   * Defaults to all events when `n` is omitted.
+   */
+  drain(n) {
+    const events = this.last(n);
+    this.clear();
+    return events;
+  }
+  /** Current number of events stored. */
+  get size() {
+    return this._size;
+  }
+  /** Maximum number of events this buffer can hold. */
+  get capacity() {
+    return this._capacity;
+  }
+  /** Total number of events ever pushed (including evicted ones). */
+  get totalPushed() {
+    return this._totalPushed;
+  }
+  /** Return events matching `predicate` without modifying the buffer. */
+  filter(predicate) {
+    return this.last().filter(predicate);
+  }
+  /** Snapshot of buffer statistics. */
+  get stats() {
+    return {
+      size: this._size,
+      capacity: this._capacity,
+      totalPushed: this._totalPushed,
+      evicted: this._totalPushed - this._size
+    };
+  }
+};
+
+// src/redactor.ts
+var JWT_PATTERN = /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g;
+var BEARER_PATTERN = /Bearer\s+\S+/gi;
+var REDACTED = "[REDACTED]";
+var REDACTED_JWT = "[REDACTED_JWT]";
+function redactInlineSecrets(text, opts) {
+  if (opts?.enabled === false) {
+    return text;
+  }
+  let result = text.replace(JWT_PATTERN, REDACTED_JWT);
+  result = result.replace(BEARER_PATTERN, (match) => {
+    const bearerWord = match.split(/\s+/)[0];
+    return `${bearerWord} ${REDACTED}`;
+  });
+  return result;
+}
+
+// src/tools/browser-console-messages.ts
+var consoleBuffer = new EventBuffer(500);
+async function browserConsoleMessages(_cdp, params) {
+  let messages = consoleBuffer.last();
+  messages = messages.map((m) => ({ ...m, text: redactInlineSecrets(m.text) }));
+  if (params.level) {
+    messages = messages.filter((m) => m.level === params.level);
+  }
+  const limit = params.limit ?? 100;
+  if (messages.length > limit) {
+    messages = messages.slice(-limit);
+  }
+  return { messages };
+}
+
+// src/tools/browser-network-requests.ts
+var STATIC_TYPES = /* @__PURE__ */ new Set([
+  "Image",
+  "Stylesheet",
+  "Font",
+  "Script",
+  "Media"
+]);
+var networkBuffer = new EventBuffer(500);
+async function browserNetworkRequests(_cdp, params) {
+  let entries = networkBuffer.last();
+  if (!params.includeStatic) {
+    entries = entries.filter((e) => !STATIC_TYPES.has(e.type));
+  }
+  if (params.filter) {
+    const filterLower = params.filter.toLowerCase();
+    entries = entries.filter((e) => e.url.toLowerCase().includes(filterLower));
+  }
+  const limit = params.limit ?? 100;
+  entries = entries.slice(0, limit);
+  const requests = entries.map((e) => ({
+    url: redactInlineSecrets(e.url),
+    method: e.method,
+    status: e.status,
+    type: e.type
+  }));
+  return { requests };
+}
+
+// src/cli/commands/obs.ts
+var snapshotCommand = {
+  name: "snapshot",
+  description: "Capture the accessibility tree of the page",
+  usage: "browsirai snapshot [-i] [-c] [-d N] [-s selector]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.compact === "true" || flags.c === "true") params.compact = true;
+    if (flags.interactive === "true" || flags.i === "true") params.interactive = true;
+    if (flags.selector) params.selector = flags.selector;
+    if (flags.s) params.selector = flags.s;
+    if (flags.depth) params.depth = parseInt(flags.depth, 10);
+    if (flags.d) params.depth = parseInt(flags.d, 10);
+    const result = await browserSnapshot(cdp, params);
+    if (result.snapshot) {
+      console.log(result.snapshot);
+    } else {
+      console.log("(empty snapshot)");
+    }
+    if (result.truncated) {
+      console.log(`
+(truncated \u2014 ${result.totalElements} total elements)`);
+    }
+  }
+};
+var screenshotCommand = {
+  name: "screenshot",
+  description: "Capture a screenshot of the page",
+  usage: "browsirai screenshot [-o file.png] [--fullPage] [--selector=...] [--format=png]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.fullPage === "true") params.fullPage = true;
+    if (flags.selector) params.selector = flags.selector;
+    if (flags.format) params.format = flags.format;
+    const result = await browserScreenshot(cdp, params);
+    const output = flags.output ?? flags.o;
+    if (output) {
+      const buffer = Buffer.from(result.base64, "base64");
+      writeFileSync(output, buffer);
+      console.log(`Screenshot saved to ${output} (${buffer.length} bytes)`);
+    } else {
+      const sizeKB = Math.round(result.base64.length * 3 / 4 / 1024);
+      console.log(`Screenshot taken (~${sizeKB}KB)`);
+      console.log("Use --output=file.png to save to disk");
+    }
+  }
+};
+var htmlCommand = {
+  name: "html",
+  description: "Retrieve page or element HTML",
+  usage: "browsirai html [--selector=...]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.selector) params.selector = flags.selector;
+    const result = await browserHtml(cdp, params);
+    if (result.error) {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+    console.log(result.html);
+  }
+};
+var evalCommand = {
+  name: "eval",
+  description: "Evaluate a JavaScript expression in the browser",
+  usage: 'browsirai eval "<expression>"',
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const expression = flags._0;
+    if (!expression) {
+      console.error("Error: Missing expression argument");
+      console.error('Usage: browsirai eval "<expression>"');
+      process.exit(1);
+    }
+    const result = await browserEval(cdp, { expression });
+    if (result.error) {
+      console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+    if (result.result === void 0) {
+      console.log("undefined");
+    } else if (result.result === null) {
+      console.log("null");
+    } else if (typeof result.result === "object") {
+      console.log(JSON.stringify(result.result, null, 2));
+    } else {
+      console.log(String(result.result));
+    }
+  }
+};
+var findCommand = {
+  name: "find",
+  description: "Find elements by ARIA role, name, or text",
+  usage: "browsirai find [--role=button] [--name=...] [--text=...]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.role) params.role = flags.role;
+    if (flags.name) params.name = flags.name;
+    if (flags.text) params.text = flags.text;
+    if (flags.nth) params.nth = parseInt(flags.nth, 10);
+    const result = await browserFind(cdp, params);
+    if (result.found) {
+      console.log(`Found ${result.ref} (role: ${result.role}, name: "${result.name}")`);
+      if (result.count > 1) {
+        console.log(`  ${result.count} total matches`);
+      }
+    } else {
+      console.log("Not found");
+      if (result.count > 0) {
+        console.log(`  ${result.count} matches exist but index out of range`);
+      }
+    }
+  }
+};
+var sourceCommand = {
+  name: "source",
+  description: "Inspect source code location of an element",
+  usage: "browsirai source [--ref=@e5] [--selector=h1]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.ref) params.ref = flags.ref;
+    if (flags.selector) params.selector = flags.selector;
+    if (!params.ref && !params.selector) {
+      console.error("Error: Either --ref or --selector is required");
+      console.error("Usage: browsirai source [--ref=@e5] [--selector=h1]");
+      process.exit(1);
+    }
+    const result = await browserInspectSource(cdp, params);
+    if (result.source) {
+      const loc = result.source;
+      const file = loc.filePath ?? "(unknown file)";
+      const line = loc.lineNumber != null ? `:${loc.lineNumber}` : "";
+      const col = loc.columnNumber != null ? `:${loc.columnNumber}` : "";
+      const component = result.componentName ?? loc.componentName ?? "(anonymous)";
+      console.log(`Component: ${component}`);
+      console.log(`Source: ${file}${line}${col}`);
+    } else {
+      console.log(`Tag: <${result.tagName}>`);
+      if (result.componentName) {
+        console.log(`Component: ${result.componentName}`);
+      }
+      console.log("Source: not found (dev mode may not be enabled)");
+    }
+    if (result.stack.length > 0) {
+      console.log("\nComponent stack:");
+      for (const loc of result.stack) {
+        const name = loc.componentName ?? "(anonymous)";
+        const line = loc.lineNumber != null ? `:${loc.lineNumber}` : "";
+        console.log(`  ${name} -> ${loc.filePath}${line}`);
+      }
+    }
+  }
+};
+var consoleCommand = {
+  name: "console",
+  description: "View captured console messages",
+  usage: "browsirai console [--level=error] [--limit=20]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.level) params.level = flags.level;
+    if (flags.limit) params.limit = parseInt(flags.limit, 10);
+    const result = await browserConsoleMessages(cdp, params);
+    if (result.messages.length === 0) {
+      console.log("No console messages captured");
+      return;
+    }
+    for (const msg of result.messages) {
+      const level = msg.level.toUpperCase().padEnd(5);
+      const ts = msg.timestamp ? new Date(msg.timestamp).toISOString().slice(11, 23) : "";
+      const prefix = ts ? `[${ts}] ${level}` : level;
+      console.log(`${prefix} ${msg.text}`);
+    }
+    console.log(`
+(${result.messages.length} messages)`);
+  }
+};
+var networkCommand = {
+  name: "network",
+  description: "View captured network requests",
+  usage: "browsirai network [--filter=*api*] [--limit=10] [--includeHeaders]",
+  run: async (cdp, args) => {
+    const flags = parseFlags(args);
+    const params = {};
+    if (flags.filter) params.filter = flags.filter;
+    if (flags.limit) params.limit = parseInt(flags.limit, 10);
+    if (flags.includeHeaders === "true") params.includeHeaders = true;
+    const result = await browserNetworkRequests(cdp, params);
+    if (result.requests.length === 0) {
+      console.log("No network requests captured");
+      return;
+    }
+    for (const req of result.requests) {
+      const status = req.status != null ? String(req.status) : "...";
+      const type = req.type ? `[${req.type}]` : "";
+      console.log(`${req.method.padEnd(6)} ${status.padEnd(3)} ${type.padEnd(10)} ${req.url}`);
+    }
+    console.log(`
+(${result.requests.length} requests)`);
+  }
+};
+var obsCommands = [
+  snapshotCommand,
+  screenshotCommand,
+  htmlCommand,
+  evalCommand,
+  findCommand,
+  sourceCommand,
+  consoleCommand,
+  networkCommand
+];
+export {
+  obsCommands
+};
+//# sourceMappingURL=obs.js.map