(0.5↑ 3.2↓)
+* *[58]
Result 1
+* [59]
Result 2
+*
+* - `[id]` — interactive element with backend index for targeting
+* - `*` prefix — newly appeared element (incremental diff)
+* - `|scroll|` — scrollable container with page counts
+* - `|shadow|` — Shadow DOM boundary
+* - `|iframe|` — iframe content
+* - `|table|` — markdown table rendering
+*/
+function generateSnapshotJs(opts = {}) {
+ const viewportExpand = opts.viewportExpand ?? 800;
+ const maxDepth = Math.max(1, Math.min(opts.maxDepth ?? 50, 200));
+ const interactiveOnly = opts.interactiveOnly ?? false;
+ const maxTextLength = opts.maxTextLength ?? 120;
+ const includeScrollInfo = opts.includeScrollInfo ?? true;
+ const bboxDedup = opts.bboxDedup ?? true;
+ const includeShadowDom = opts.includeShadowDom ?? true;
+ const includeIframes = opts.includeIframes ?? true;
+ const maxIframes = opts.maxIframes ?? 5;
+ const paintOrderCheck = opts.paintOrderCheck ?? true;
+ const annotateRefs = opts.annotateRefs ?? true;
+ const reportHidden = opts.reportHidden ?? true;
+ const filterAds = opts.filterAds ?? true;
+ const markdownTables = opts.markdownTables ?? true;
+ const previousHashes = opts.previousHashes ?? null;
+ return `
+(() => {
+ 'use strict';
+
+ // ── Config ─────────────────────────────────────────────────────────
+ const VIEWPORT_EXPAND = ${viewportExpand};
+ const MAX_DEPTH = ${maxDepth};
+ const INTERACTIVE_ONLY = ${interactiveOnly};
+ const MAX_TEXT_LEN = ${maxTextLength};
+ const INCLUDE_SCROLL_INFO = ${includeScrollInfo};
+ const BBOX_DEDUP = ${bboxDedup};
+ const INCLUDE_SHADOW_DOM = ${includeShadowDom};
+ const INCLUDE_IFRAMES = ${includeIframes};
+ const MAX_IFRAMES = ${maxIframes};
+ const PAINT_ORDER_CHECK = ${paintOrderCheck};
+ const ANNOTATE_REFS = ${annotateRefs};
+ const REPORT_HIDDEN = ${reportHidden};
+ const FILTER_ADS = ${filterAds};
+ const MARKDOWN_TABLES = ${markdownTables};
+ const PREV_HASHES = ${previousHashes ? `new Set(${previousHashes})` : "null"};
+
+ // ── Constants ──────────────────────────────────────────────────────
+
+ const SKIP_TAGS = new Set([
+ 'script', 'style', 'noscript', 'link', 'meta', 'head',
+ 'template', 'br', 'wbr', 'col', 'colgroup',
+ ]);
+
+ const SVG_CHILDREN = new Set([
+ 'path', 'rect', 'g', 'circle', 'ellipse', 'line', 'polyline',
+ 'polygon', 'use', 'defs', 'clippath', 'mask', 'pattern',
+ 'text', 'tspan', 'lineargradient', 'radialgradient', 'stop',
+ 'filter', 'fegaussianblur', 'fecolormatrix', 'feblend',
+ 'symbol', 'marker', 'foreignobject', 'desc', 'title',
+ ]);
+
+ const INTERACTIVE_TAGS = new Set([
+ 'a', 'button', 'input', 'select', 'textarea', 'details',
+ 'summary', 'option', 'optgroup',
+ ]);
+
+ const INTERACTIVE_ROLES = new Set([
+ 'button', 'link', 'menuitem', 'option', 'radio', 'checkbox',
+ 'tab', 'textbox', 'combobox', 'slider', 'spinbutton',
+ 'searchbox', 'switch', 'menuitemcheckbox', 'menuitemradio',
+ 'treeitem', 'gridcell', 'row',
+ ]);
+
+ const LANDMARK_ROLES = new Set([
+ 'main', 'navigation', 'banner', 'search', 'region',
+ 'complementary', 'contentinfo', 'form', 'dialog',
+ ]);
+
+ const LANDMARK_TAGS = new Set([
+ 'nav', 'main', 'header', 'footer', 'aside', 'form',
+ 'search', 'dialog', 'section', 'article',
+ ]);
+
+ const ATTR_WHITELIST = new Set([
+ 'id', 'name', 'type', 'value', 'placeholder', 'title', 'alt',
+ 'role', 'aria-label', 'aria-expanded', 'aria-checked', 'aria-selected',
+ 'aria-disabled', 'aria-valuemin', 'aria-valuemax', 'aria-valuenow',
+ 'aria-haspopup', 'aria-live', 'aria-required',
+ 'href', 'src', 'action', 'method', 'for', 'checked', 'selected',
+ 'disabled', 'required', 'multiple', 'accept', 'min', 'max',
+ 'pattern', 'maxlength', 'minlength', 'data-testid', 'data-test',
+ 'contenteditable', 'tabindex', 'autocomplete',
+ ]);
+
+ const PROPAGATING_TAGS = new Set(['a', 'button']);
+
+ const AD_PATTERNS = [
+ 'googleadservices.com', 'doubleclick.net', 'googlesyndication.com',
+ 'facebook.com/tr', 'analytics.google.com', 'connect.facebook.net',
+ 'ad.doubleclick', 'pagead', 'adsense',
+ ];
+
+ const AD_SELECTOR_RE = /\\b(ad[_-]?(?:banner|container|wrapper|slot|unit|block|frame|leaderboard|sidebar)|google[_-]?ad|sponsored|adsbygoogle|banner[_-]?ad)\\b/i;
+
+ // Search element indicators for heuristic detection
+ const SEARCH_INDICATORS = new Set([
+ 'search', 'magnify', 'glass', 'lookup', 'find', 'query',
+ 'search-icon', 'search-btn', 'search-button', 'searchbox',
+ 'fa-search', 'icon-search', 'btn-search',
+ ]);
+
+ // ── Viewport & Layout Helpers ──────────────────────────────────────
+
+ const vw = window.innerWidth;
+ const vh = window.innerHeight;
+
+ function isInExpandedViewport(rect) {
+ if (!rect || (rect.width === 0 && rect.height === 0)) return false;
+ return rect.bottom > -VIEWPORT_EXPAND && rect.top < vh + VIEWPORT_EXPAND &&
+ rect.right > -VIEWPORT_EXPAND && rect.left < vw + VIEWPORT_EXPAND;
+ }
+
+ function isVisibleByCSS(el) {
+ const style = el.style;
+ if (style.display === 'none') return false;
+ if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
+ if (style.opacity === '0') return false;
+ try {
+ const cs = window.getComputedStyle(el);
+ if (cs.display === 'none') return false;
+ if (cs.visibility === 'hidden') return false;
+ if (parseFloat(cs.opacity) <= 0) return false;
+ if (cs.clip === 'rect(0px, 0px, 0px, 0px)' && cs.position === 'absolute') return false;
+ if (cs.overflow === 'hidden' && el.offsetWidth === 0 && el.offsetHeight === 0) return false;
+ } catch {}
+ return true;
+ }
+
+ // ── Paint Order Occlusion ──────────────────────────────────────────
+
+ function isOccludedByOverlay(el) {
+ if (!PAINT_ORDER_CHECK) return false;
+ try {
+ const rect = el.getBoundingClientRect();
+ if (rect.width === 0 || rect.height === 0) return false;
+ const cx = rect.left + rect.width / 2;
+ const cy = rect.top + rect.height / 2;
+ if (cx < 0 || cy < 0 || cx > vw || cy > vh) return false;
+ const topEl = document.elementFromPoint(cx, cy);
+ if (!topEl || topEl === el || el.contains(topEl) || topEl.contains(el)) return false;
+ const cs = window.getComputedStyle(topEl);
+ if (parseFloat(cs.opacity) < 0.5) return false;
+ const bg = cs.backgroundColor;
+ if (bg === 'rgba(0, 0, 0, 0)' || bg === 'transparent') return false;
+ return true;
+ } catch { return false; }
+ }
+
+ // ── Ad/Noise Detection ─────────────────────────────────────────────
+
+ function isAdElement(el) {
+ if (!FILTER_ADS) return false;
+ try {
+ const id = el.id || '';
+ const cls = el.className || '';
+ const testStr = id + ' ' + (typeof cls === 'string' ? cls : '');
+ if (AD_SELECTOR_RE.test(testStr)) return true;
+ if (el.tagName === 'IFRAME') {
+ const src = el.src || '';
+ for (const p of AD_PATTERNS) { if (src.includes(p)) return true; }
+ }
+ if (el.hasAttribute('data-ad') || el.hasAttribute('data-ad-slot') ||
+ el.hasAttribute('data-adunit') || el.hasAttribute('data-google-query-id')) return true;
+ } catch {}
+ return false;
+ }
+
+ // ── Interactivity Detection ────────────────────────────────────────
+
+ // Check if element contains a form control within limited depth (handles label/span wrappers)
+ function hasFormControlDescendant(el, maxDepth = 2) {
+ if (maxDepth <= 0) return false;
+ for (const child of el.children || []) {
+ const tag = child.tagName?.toLowerCase();
+ if (tag === 'input' || tag === 'select' || tag === 'textarea') return true;
+ if (hasFormControlDescendant(child, maxDepth - 1)) return true;
+ }
+ return false;
+ }
+
+ function isInteractive(el) {
+ const tag = el.tagName.toLowerCase();
+ if (INTERACTIVE_TAGS.has(tag)) {
+ // Skip labels that proxy via "for" to avoid double-activating external inputs
+ if (tag === 'label') {
+ if (el.hasAttribute('for')) return false;
+ // Detect labels that wrap form controls up to two levels deep (label > span > input)
+ if (hasFormControlDescendant(el, 2)) return true;
+ }
+ if (el.disabled && (tag === 'button' || tag === 'input')) return false;
+ return true;
}
- });
- chrome.tabs.onUpdated.addListener(async (tabId, info) => {
- if (info.url && !isDebuggableUrl$1(info.url)) {
- await detach(tabId);
+ // Span wrappers for UI components - check if they contain form controls
+ if (tag === 'span') {
+ if (hasFormControlDescendant(el, 2)) return true;
}
- });
- chrome.debugger.onEvent.addListener(async (source, method, params) => {
- const tabId = source.tabId;
- if (!tabId) return;
- const state = networkCaptures.get(tabId);
- if (!state) return;
- if (method === "Network.requestWillBeSent") {
- const requestId = String(params?.requestId || "");
- const request = params?.request;
- const entry = getOrCreateNetworkCaptureEntry(tabId, requestId, {
- url: request?.url,
- method: request?.method,
- requestHeaders: normalizeHeaders(request?.headers)
- });
- if (!entry) return;
- entry.requestBodyKind = request?.hasPostData ? "string" : "empty";
- entry.requestBodyPreview = String(request?.postData || "").slice(0, 4e3);
- try {
- const postData = await chrome.debugger.sendCommand({ tabId }, "Network.getRequestPostData", { requestId });
- if (postData?.postData) {
- entry.requestBodyKind = "string";
- entry.requestBodyPreview = postData.postData.slice(0, 4e3);
+ const role = el.getAttribute('role');
+ if (role && INTERACTIVE_ROLES.has(role)) return true;
+ if (el.hasAttribute('onclick') || el.hasAttribute('onmousedown') || el.hasAttribute('ontouchstart')) return true;
+ if (el.hasAttribute('tabindex') && el.getAttribute('tabindex') !== '-1') return true;
+ // Framework event listener detection (React/Vue/Angular onClick)
+ if (hasFrameworkListener(el)) return true;
+ try { if (window.getComputedStyle(el).cursor === 'pointer') return true; } catch {}
+ if (el.isContentEditable && el.getAttribute('contenteditable') !== 'false') return true;
+ // Search element heuristic detection
+ if (isSearchElement(el)) return true;
+ return false;
+ }
+
+ function hasFrameworkListener(el) {
+ try {
+ // React: __reactProps$xxx / __reactEvents$xxx with onClick/onMouseDown
+ for (const key of Object.keys(el)) {
+ if (key.startsWith('__reactProps$') || key.startsWith('__reactEvents$')) {
+ const props = el[key];
+ if (props && (props.onClick || props.onMouseDown || props.onPointerDown)) return true;
}
- } catch {
}
- return;
+ // Vue 3: _vei (Vue Event Invoker) with onClick
+ if (el._vei && (el._vei.onClick || el._vei.click || el._vei.onMousedown)) return true;
+ // Vue 2: __vue__ instance with $listeners
+ if (el.__vue__?.$listeners?.click) return true;
+ // Angular: ng-reflect-click binding
+ if (el.hasAttribute('ng-reflect-click')) return true;
+ } catch { /* ignore errors from cross-origin or frozen objects */ }
+ return false;
+ }
+
+ function isSearchElement(el) {
+ // Check class names for search indicators
+ // Note: SVG elements have className as SVGAnimatedString (not a string), use baseVal
+ const className = (typeof el.className === 'string' ? el.className : el.className?.baseVal || '').toLowerCase();
+ const classes = className.split(/\\s+/).filter(Boolean);
+ for (const cls of classes) {
+ const cleaned = cls.replace(/[^a-z0-9-]/g, '');
+ if (SEARCH_INDICATORS.has(cleaned)) return true;
}
- if (method === "Network.responseReceived") {
- const requestId = String(params?.requestId || "");
- const response = params?.response;
- const entry = getOrCreateNetworkCaptureEntry(tabId, requestId, {
- url: response?.url
- });
- if (!entry) return;
- entry.responseStatus = response?.status;
- entry.responseContentType = response?.mimeType || "";
- entry.responseHeaders = normalizeHeaders(response?.headers);
- return;
+ // Check id for search indicators
+ const id = el.id?.toLowerCase() || '';
+ const cleanedId = id.replace(/[^a-z0-9-]/g, '');
+ if (SEARCH_INDICATORS.has(cleanedId)) return true;
+ // Check data-* attributes for search functionality
+ for (const attr of el.attributes || []) {
+ if (attr.name.startsWith('data-')) {
+ const value = attr.value.toLowerCase();
+ for (const kw of SEARCH_INDICATORS) {
+ if (value.includes(kw)) return true;
+ }
+ }
}
- if (method === "Network.loadingFinished") {
- const requestId = String(params?.requestId || "");
- const stateEntryIndex = state.requestToIndex.get(requestId);
- if (stateEntryIndex === void 0) return;
- const entry = state.entries[stateEntryIndex];
- if (!entry) return;
- try {
- const body = await chrome.debugger.sendCommand({ tabId }, "Network.getResponseBody", { requestId });
- if (typeof body?.body === "string") {
- entry.responsePreview = body.base64Encoded ? `base64:${body.body.slice(0, 4e3)}` : body.body.slice(0, 4e3);
+ return false;
+ }
+
+ function isLandmark(el) {
+ const role = el.getAttribute('role');
+ if (role && LANDMARK_ROLES.has(role)) return true;
+ return LANDMARK_TAGS.has(el.tagName.toLowerCase());
+ }
+
+ // ── Scrollability Detection ────────────────────────────────────────
+
+ function getScrollInfo(el) {
+ if (!INCLUDE_SCROLL_INFO) return null;
+ const sh = el.scrollHeight, ch = el.clientHeight;
+ const sw = el.scrollWidth, cw = el.clientWidth;
+ const isV = sh > ch + 5, isH = sw > cw + 5;
+ if (!isV && !isH) return null;
+ try {
+ const cs = window.getComputedStyle(el);
+ const scrollable = ['auto', 'scroll', 'overlay'];
+ const tag = el.tagName.toLowerCase();
+ const isBody = tag === 'body' || tag === 'html';
+ if (isV && !isBody && !scrollable.includes(cs.overflowY)) return null;
+ const info = {};
+ if (isV) {
+ const above = ch > 0 ? +(el.scrollTop / ch).toFixed(1) : 0;
+ const below = ch > 0 ? +((sh - ch - el.scrollTop) / ch).toFixed(1) : 0;
+ if (above > 0 || below > 0) info.v = { above, below };
+ }
+ if (isH && scrollable.includes(cs.overflowX)) {
+ info.h = { pct: cw > 0 ? Math.round(el.scrollLeft / (sw - cw) * 100) : 0 };
+ }
+ return Object.keys(info).length > 0 ? info : null;
+ } catch { return null; }
+ }
+
+ // ── BBox Containment Check ─────────────────────────────────────────
+
+ function isContainedBy(childRect, parentRect, threshold) {
+ if (!childRect || !parentRect) return false;
+ const cArea = childRect.width * childRect.height;
+ if (cArea === 0) return false;
+ const xO = Math.max(0, Math.min(childRect.right, parentRect.right) - Math.max(childRect.left, parentRect.left));
+ const yO = Math.max(0, Math.min(childRect.bottom, parentRect.bottom) - Math.max(childRect.top, parentRect.top));
+ return (xO * yO) / cArea >= threshold;
+ }
+
+ // ── Text Helpers ───────────────────────────────────────────────────
+
+ function getDirectText(el) {
+ let text = '';
+ for (const child of el.childNodes) {
+ if (child.nodeType === 3) {
+ const t = child.textContent.trim();
+ if (t) text += (text ? ' ' : '') + t;
+ }
+ }
+ return text;
+ }
+
+ function capText(s) {
+ if (!s) return '';
+ const t = s.replace(/\\s+/g, ' ').trim();
+ return t.length > MAX_TEXT_LEN ? t.slice(0, MAX_TEXT_LEN) + '…' : t;
+ }
+
+ // ── Element Hashing (for incremental diff) ─────────────────────────
+
+ function hashElement(el) {
+ // Simple hash: tag + id + className + textContent prefix
+ const tag = el.tagName || '';
+ const id = el.id || '';
+ const cls = (typeof el.className === 'string' ? el.className : '').slice(0, 50);
+ const text = (el.textContent || '').trim().slice(0, 40);
+ const s = tag + '|' + id + '|' + cls + '|' + text;
+ let h = 0;
+ for (let i = 0; i < s.length; i++) {
+ h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+ }
+ return '' + (h >>> 0); // unsigned
+ }
+
+ // ── Attribute Serialization ────────────────────────────────────────
+
+ function serializeAttrs(el) {
+ const parts = [];
+ for (const attr of el.attributes) {
+ if (!ATTR_WHITELIST.has(attr.name)) continue;
+ let val = attr.value.trim();
+ if (!val) continue;
+ if (val.length > 120) val = val.slice(0, 100) + '…';
+ if (attr.name === 'type' && val.toLowerCase() === el.tagName.toLowerCase()) continue;
+ if (attr.name === 'value' && el.getAttribute('type') === 'password') { parts.push('value=••••'); continue; }
+ if (attr.name === 'href') {
+ if (val.startsWith('javascript:')) continue;
+ try {
+ const u = new URL(val, location.origin);
+ if (u.origin === location.origin) val = u.pathname + u.search + u.hash;
+ } catch {}
+ }
+ parts.push(attr.name + '=' + val);
+ }
+ // Synthetic attributes
+ const tag = el.tagName;
+ if (tag === 'INPUT') {
+ const type = (el.getAttribute('type') || 'text').toLowerCase();
+ const fmts = { 'date':'YYYY-MM-DD', 'time':'HH:MM', 'datetime-local':'YYYY-MM-DDTHH:MM', 'month':'YYYY-MM', 'week':'YYYY-W##' };
+ if (fmts[type]) parts.push('format=' + fmts[type]);
+ if (['text','email','tel','url','search','number','date','time','datetime-local','month','week'].includes(type)) {
+ if (el.value && !parts.some(p => p.startsWith('value='))) parts.push('value=' + capText(el.value));
+ }
+ if (type === 'password' && el.value && !parts.some(p => p.startsWith('value='))) parts.push('value=••••');
+ if ((type === 'checkbox' || type === 'radio') && el.checked && !parts.some(p => p.startsWith('checked'))) parts.push('checked');
+ if (type === 'file' && el.files && el.files.length > 0) parts.push('files=' + Array.from(el.files).map(f => f.name).join(','));
+ }
+ if (tag === 'TEXTAREA' && el.value && !parts.some(p => p.startsWith('value='))) parts.push('value=' + capText(el.value));
+ if (tag === 'SELECT') {
+ const sel = el.options?.[el.selectedIndex];
+ if (sel && !parts.some(p => p.startsWith('value='))) parts.push('value=' + capText(sel.textContent));
+ const optEls = Array.from(el.options || []).slice(0, 6);
+ if (optEls.length > 0) {
+ const ot = optEls.map(o => capText(o.textContent).slice(0, 30));
+ if (el.options.length > 6) ot.push('…' + (el.options.length - 6) + ' more');
+ parts.push('options=[' + ot.join('|') + ']');
+ }
+ }
+ return parts.join(' ');
+ }
+
+ // ── Table → Markdown Serialization ─────────────────────────────────
+
+ function serializeTable(table, depth) {
+ if (!MARKDOWN_TABLES) return false;
+ try {
+ const rows = table.querySelectorAll('tr');
+ if (rows.length === 0 || rows.length > 50) return false; // skip huge tables
+ const grid = [];
+ let maxCols = 0;
+ for (const row of rows) {
+ const cells = [];
+ for (const cell of row.querySelectorAll('th, td')) {
+ let text = capText(cell.textContent || '');
+ // Include interactive elements in cells
+ const links = cell.querySelectorAll('a[href]');
+ if (links.length === 1 && text) {
+ const href = links[0].getAttribute('href');
+ if (href && !href.startsWith('javascript:')) {
+ try {
+ const u = new URL(href, location.origin);
+ text = '[' + text + '](' + (u.origin === location.origin ? u.pathname + u.search : href) + ')';
+ } catch { text = '[' + text + '](' + href + ')'; }
+ }
+ }
+ cells.push(text || '');
}
- } catch {
+ if (cells.length > 0) {
+ grid.push(cells);
+ if (cells.length > maxCols) maxCols = cells.length;
+ }
+ }
+ if (grid.length < 2 || maxCols === 0) return false; // need at least header + 1 row
+ // Pad rows to maxCols
+ for (const row of grid) { while (row.length < maxCols) row.push(''); }
+ // Compute column widths
+ const widths = [];
+ for (let c = 0; c < maxCols; c++) {
+ let w = 3;
+ for (const row of grid) { if (row[c].length > w) w = Math.min(row[c].length, 40); }
+ widths.push(w);
+ }
+ const indent = ' '.repeat(depth);
+ const tableLines = [];
+ // Header
+ tableLines.push(indent + '| ' + grid[0].map((c, i) => c.padEnd(widths[i])).join(' | ') + ' |');
+ tableLines.push(indent + '| ' + widths.map(w => '-'.repeat(w)).join(' | ') + ' |');
+ // Body
+ for (let r = 1; r < grid.length; r++) {
+ tableLines.push(indent + '| ' + grid[r].map((c, i) => c.padEnd(widths[i])).join(' | ') + ' |');
+ }
+ return tableLines;
+ } catch { return false; }
+ }
+
+ // ── Main Tree Walk ─────────────────────────────────────────────────
+
+ let interactiveIndex = 0;
+ const lines = [];
+ const hiddenInteractives = [];
+ const currentHashes = [];
+ let iframeCount = 0;
+
+ function walk(el, depth, parentPropagatingRect) {
+ if (depth > MAX_DEPTH) return false;
+ if (el.nodeType !== 1) return false;
+
+ const tag = el.tagName.toLowerCase();
+ if (SKIP_TAGS.has(tag)) return false;
+ if (isAdElement(el)) return false;
+
+ // SVG: emit tag, collapse children
+ if (tag === 'svg') {
+ const attrs = serializeAttrs(el);
+ const interactive = isInteractive(el);
+ let prefix = '';
+ if (interactive) {
+ interactiveIndex++;
+ if (ANNOTATE_REFS) el.setAttribute('data-opencli-ref', '' + interactiveIndex);
+ prefix = '[' + interactiveIndex + ']';
}
+ lines.push(' '.repeat(depth) + prefix + '
');
+ return interactive;
}
- });
-}
+ if (SVG_CHILDREN.has(tag)) return false;
-let ws = null;
-let reconnectTimer = null;
-let reconnectAttempts = 0;
-const _origLog = console.log.bind(console);
-const _origWarn = console.warn.bind(console);
-const _origError = console.error.bind(console);
-function forwardLog(level, args) {
- if (!ws || ws.readyState !== WebSocket.OPEN) return;
- try {
- const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
- ws.send(JSON.stringify({ type: "log", level, msg, ts: Date.now() }));
- } catch {
+ // Table: try markdown serialization before generic walk
+ if (tag === 'table' && MARKDOWN_TABLES) {
+ const tableLines = serializeTable(el, depth);
+ if (tableLines) {
+ const indent = ' '.repeat(depth);
+ lines.push(indent + '|table|');
+ for (const tl of tableLines) lines.push(tl);
+ return false; // tables usually non-interactive
+ }
+ // Fall through to generic walk if markdown failed
+ }
+
+ // iframe handling
+ if (tag === 'iframe' && INCLUDE_IFRAMES && iframeCount < MAX_IFRAMES) {
+ return walkIframe(el, depth);
+ }
+
+ // Visibility check
+ let rect;
+ try { rect = el.getBoundingClientRect(); } catch { return false; }
+ const hasArea = rect.width > 0 && rect.height > 0;
+ if (hasArea && !isVisibleByCSS(el)) {
+ if (!(tag === 'input' && el.type === 'file')) return false;
+ }
+
+ const interactive = isInteractive(el);
+
+ // Viewport threshold pruning
+ if (hasArea && !isInExpandedViewport(rect)) {
+ if (interactive && REPORT_HIDDEN) {
+ const scrollDist = rect.top > vh ? rect.top - vh : -rect.bottom;
+ const pagesAway = Math.abs(scrollDist / vh).toFixed(1);
+ const direction = rect.top > vh ? 'below' : 'above';
+ const text = capText(getDirectText(el) || el.getAttribute('aria-label') || el.getAttribute('title') || '');
+ hiddenInteractives.push({ tag, text, direction, pagesAway });
+ }
+ return false;
+ }
+
+ // Paint order occlusion
+ if (interactive && hasArea && isOccludedByOverlay(el)) return false;
+
+ const landmark = isLandmark(el);
+ const scrollInfo = getScrollInfo(el);
+ const isScrollable = scrollInfo !== null;
+
+ // BBox dedup
+ let excludedByParent = false;
+ if (BBOX_DEDUP && parentPropagatingRect && !interactive) {
+ if (hasArea && isContainedBy(rect, parentPropagatingRect, 0.95)) {
+ const hasSemantic = el.hasAttribute('aria-label') ||
+ (el.getAttribute('role') && INTERACTIVE_ROLES.has(el.getAttribute('role')));
+ if (!hasSemantic && !['input','select','textarea','label'].includes(tag)) {
+ excludedByParent = true;
+ }
+ }
+ }
+
+ let propagateRect = parentPropagatingRect;
+ if (BBOX_DEDUP && PROPAGATING_TAGS.has(tag) && hasArea) propagateRect = rect;
+
+ // Process children
+ const origLen = lines.length;
+ let hasInteractiveDescendant = false;
+
+ for (const child of el.children) {
+ const r = walk(child, depth + 1, propagateRect);
+ if (r) hasInteractiveDescendant = true;
+ }
+
+ // Shadow DOM
+ if (INCLUDE_SHADOW_DOM && el.shadowRoot) {
+ const shadowOrigLen = lines.length;
+ for (const child of el.shadowRoot.children) {
+ const r = walk(child, depth + 1, propagateRect);
+ if (r) hasInteractiveDescendant = true;
+ }
+ if (lines.length > shadowOrigLen) {
+ lines.splice(shadowOrigLen, 0, ' '.repeat(depth + 1) + '|shadow|');
+ }
+ }
+
+ const childLinesCount = lines.length - origLen;
+ const text = capText(getDirectText(el));
+
+ // Decide whether to emit
+ if (INTERACTIVE_ONLY && !interactive && !landmark && !hasInteractiveDescendant && !text) {
+ lines.length = origLen;
+ return false;
+ }
+ if (excludedByParent && !interactive && !isScrollable) return hasInteractiveDescendant;
+ if (!interactive && !isScrollable && !text && childLinesCount === 0 && !landmark) return false;
+
+ // ── Emit node ────────────────────────────────────────────────────
+ const indent = ' '.repeat(depth);
+ let line = indent;
+
+ // Incremental diff: mark new elements with *
+ if (PREV_HASHES) {
+ const h = hashElement(el);
+ currentHashes.push(h);
+ if (!PREV_HASHES.has(h)) line += '*';
+ } else {
+ currentHashes.push(hashElement(el));
+ }
+
+ // Scroll marker
+ if (isScrollable && !interactive) line += '|scroll|';
+
+ // Interactive index + data-ref
+ if (interactive) {
+ interactiveIndex++;
+ if (ANNOTATE_REFS) el.setAttribute('data-opencli-ref', '' + interactiveIndex);
+ line += isScrollable ? '|scroll[' + interactiveIndex + ']|' : '[' + interactiveIndex + ']';
+ }
+
+ // Tag + attributes
+ const attrs = serializeAttrs(el);
+ line += '<' + tag;
+ if (attrs) line += ' ' + attrs;
+
+ // Scroll info suffix, inline text, or self-close
+ if (isScrollable && scrollInfo) {
+ const parts = [];
+ if (scrollInfo.v) parts.push(scrollInfo.v.above + '↑ ' + scrollInfo.v.below + '↓');
+ if (scrollInfo.h) parts.push('h:' + scrollInfo.h.pct + '%');
+ line += ' /> (' + parts.join(', ') + ')';
+ } else if (text && childLinesCount === 0) {
+ line += '>' + text + '';
+ } else {
+ line += ' />';
+ }
+
+ lines.splice(origLen, 0, line);
+ if (text && childLinesCount > 0) lines.splice(origLen + 1, 0, indent + ' ' + text);
+
+ return interactive || hasInteractiveDescendant;
+ }
+
+ // ── iframe Processing ──────────────────────────────────────────────
+
+ function walkIframe(el, depth) {
+ const indent = ' '.repeat(depth);
+ try {
+ const doc = el.contentDocument;
+ if (!doc || !doc.body) {
+ const attrs = serializeAttrs(el);
+ lines.push(indent + '|iframe|
(cross-origin)');
+ return false;
+ }
+ iframeCount++;
+ const attrs = serializeAttrs(el);
+ lines.push(indent + '|iframe|
');
+ let has = false;
+ for (const child of doc.body.children) {
+ if (walk(child, depth + 1, null)) has = true;
+ }
+ return has;
+ } catch {
+ const attrs = serializeAttrs(el);
+ lines.push(indent + '|iframe|
(blocked)');
+ return false;
+ }
}
+
+ // ── Entry Point ────────────────────────────────────────────────────
+
+ lines.push('url: ' + location.href);
+ lines.push('title: ' + document.title);
+ lines.push('viewport: ' + vw + 'x' + vh);
+ const pageScrollInfo = getScrollInfo(document.documentElement) || getScrollInfo(document.body);
+ if (pageScrollInfo && pageScrollInfo.v) {
+ lines.push('page_scroll: ' + pageScrollInfo.v.above + '↑ ' + pageScrollInfo.v.below + '↓');
+ }
+ lines.push('---');
+
+ const root = document.body || document.documentElement;
+ if (root) walk(root, 0, null);
+
+ // Hidden interactive elements hint
+ if (REPORT_HIDDEN && hiddenInteractives.length > 0) {
+ lines.push('---');
+ lines.push('hidden_interactive (' + hiddenInteractives.length + '):');
+ const shown = hiddenInteractives.slice(0, 10);
+ for (const h of shown) {
+ const label = h.text ? ' "' + h.text + '"' : '';
+ lines.push(' <' + h.tag + '>' + label + ' ~' + h.pagesAway + ' pages ' + h.direction);
+ }
+ if (hiddenInteractives.length > 10) lines.push(' …' + (hiddenInteractives.length - 10) + ' more');
+ }
+
+ // Footer
+ lines.push('---');
+ lines.push('interactive: ' + interactiveIndex + ' | iframes: ' + iframeCount);
+
+ // Store hashes on window for next diff snapshot
+ try { window.__opencli_prev_hashes = JSON.stringify(currentHashes); } catch {}
+
+ return lines.join('\\n');
+})()
+ `.trim();
+}
+//#endregion
+//#region src/background.ts
+var ws = null;
+var reconnectTimer = null;
+var reconnectAttempts = 0;
+var _origLog = console.log.bind(console);
+var _origWarn = console.warn.bind(console);
+var _origError = console.error.bind(console);
+function forwardLog(level, args) {
+ if (!ws || ws.readyState !== WebSocket.OPEN) return;
+ try {
+ const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+ ws.send(JSON.stringify({
+ type: "log",
+ level,
+ msg,
+ ts: Date.now()
+ }));
+ } catch {}
}
console.log = (...args) => {
- _origLog(...args);
- forwardLog("info", args);
+ _origLog(...args);
+ forwardLog("info", args);
};
console.warn = (...args) => {
- _origWarn(...args);
- forwardLog("warn", args);
+ _origWarn(...args);
+ forwardLog("warn", args);
};
console.error = (...args) => {
- _origError(...args);
- forwardLog("error", args);
+ _origError(...args);
+ forwardLog("error", args);
};
+/**
+* Probe the daemon via its /ping HTTP endpoint before attempting a WebSocket
+* connection. fetch() failures are silently catchable; new WebSocket() is not
+* — Chrome logs ERR_CONNECTION_REFUSED to the extension error page before any
+* JS handler can intercept it. By keeping the probe inside connect() every
+* call site remains unchanged and the guard can never be accidentally skipped.
+*/
async function connect() {
- if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
- try {
- const res = await fetch(DAEMON_PING_URL, { signal: AbortSignal.timeout(1e3) });
- if (!res.ok) return;
- } catch {
- return;
- }
- try {
- ws = new WebSocket(DAEMON_WS_URL);
- } catch {
- scheduleReconnect();
- return;
- }
- ws.onopen = () => {
- console.log("[opencli] Connected to daemon");
- reconnectAttempts = 0;
- if (reconnectTimer) {
- clearTimeout(reconnectTimer);
- reconnectTimer = null;
- }
- ws?.send(JSON.stringify({ type: "hello", version: chrome.runtime.getManifest().version }));
- };
- ws.onmessage = async (event) => {
- try {
- const command = JSON.parse(event.data);
- const result = await handleCommand(command);
- ws?.send(JSON.stringify(result));
- } catch (err) {
- console.error("[opencli] Message handling error:", err);
- }
- };
- ws.onclose = () => {
- console.log("[opencli] Disconnected from daemon");
- ws = null;
- scheduleReconnect();
- };
- ws.onerror = () => {
- ws?.close();
- };
-}
-const MAX_EAGER_ATTEMPTS = 6;
+ if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
+ try {
+ if (!(await fetch(DAEMON_PING_URL, { signal: AbortSignal.timeout(1e3) })).ok) return;
+ } catch {
+ return;
+ }
+ try {
+ ws = new WebSocket(DAEMON_WS_URL);
+ } catch {
+ scheduleReconnect();
+ return;
+ }
+ ws.onopen = () => {
+ console.log("[opencli] Connected to daemon");
+ reconnectAttempts = 0;
+ if (reconnectTimer) {
+ clearTimeout(reconnectTimer);
+ reconnectTimer = null;
+ }
+ ws?.send(JSON.stringify({
+ type: "hello",
+ version: chrome.runtime.getManifest().version
+ }));
+ };
+ ws.onmessage = async (event) => {
+ try {
+ const result = await handleCommand(JSON.parse(event.data));
+ ws?.send(JSON.stringify(result));
+ } catch (err) {
+ console.error("[opencli] Message handling error:", err);
+ }
+ };
+ ws.onclose = () => {
+ console.log("[opencli] Disconnected from daemon");
+ ws = null;
+ scheduleReconnect();
+ };
+ ws.onerror = () => {
+ ws?.close();
+ };
+}
+/**
+* After MAX_EAGER_ATTEMPTS (reaching 60s backoff), stop scheduling reconnects.
+* The keepalive alarm (~24s) will still call connect() periodically, but at a
+* much lower frequency — reducing console noise when the daemon is not running.
+*/
+var MAX_EAGER_ATTEMPTS = 6;
function scheduleReconnect() {
- if (reconnectTimer) return;
- reconnectAttempts++;
- if (reconnectAttempts > MAX_EAGER_ATTEMPTS) return;
- const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
- reconnectTimer = setTimeout(() => {
- reconnectTimer = null;
- void connect();
- }, delay);
-}
-const automationSessions = /* @__PURE__ */ new Map();
-const WINDOW_IDLE_TIMEOUT = 3e4;
+ if (reconnectTimer) return;
+ reconnectAttempts++;
+ if (reconnectAttempts > MAX_EAGER_ATTEMPTS) return;
+ const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
+ reconnectTimer = setTimeout(() => {
+ reconnectTimer = null;
+ connect();
+ }, delay);
+}
+var automationSessions = /* @__PURE__ */ new Map();
+var WINDOW_IDLE_TIMEOUT = 3e4;
+var windowFocused = false;
function getWorkspaceKey(workspace) {
- return workspace?.trim() || "default";
+ return workspace?.trim() || "default";
}
function resetWindowIdleTimer(workspace) {
- const session = automationSessions.get(workspace);
- if (!session) return;
- if (session.idleTimer) clearTimeout(session.idleTimer);
- session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
- session.idleTimer = setTimeout(async () => {
- const current = automationSessions.get(workspace);
- if (!current) return;
- if (!current.owned) {
- console.log(`[opencli] Borrowed workspace ${workspace} detached from window ${current.windowId} (idle timeout)`);
- automationSessions.delete(workspace);
- return;
- }
- try {
- await chrome.windows.remove(current.windowId);
- console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
- } catch {
- }
- automationSessions.delete(workspace);
- }, WINDOW_IDLE_TIMEOUT);
+ const session = automationSessions.get(workspace);
+ if (!session) return;
+ if (session.idleTimer) clearTimeout(session.idleTimer);
+ session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
+ session.idleTimer = setTimeout(async () => {
+ const current = automationSessions.get(workspace);
+ if (!current) return;
+ if (!current.owned) {
+ console.log(`[opencli] Borrowed workspace ${workspace} detached from window ${current.windowId} (idle timeout)`);
+ automationSessions.delete(workspace);
+ return;
+ }
+ try {
+ await chrome.windows.remove(current.windowId);
+ console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
+ } catch {}
+ automationSessions.delete(workspace);
+ }, WINDOW_IDLE_TIMEOUT);
}
+/** Get or create the dedicated automation window.
+* @param initialUrl — if provided (http/https), used as the initial page instead of about:blank.
+* This avoids an extra blank-page→target-domain navigation on first command.
+*/
async function getAutomationWindow(workspace, initialUrl) {
- const existing = automationSessions.get(workspace);
- if (existing) {
- try {
- await chrome.windows.get(existing.windowId);
- return existing.windowId;
- } catch {
- automationSessions.delete(workspace);
- }
- }
- const startUrl = initialUrl && isSafeNavigationUrl(initialUrl) ? initialUrl : BLANK_PAGE;
- const win = await chrome.windows.create({
- url: startUrl,
- focused: false,
- width: 1280,
- height: 900,
- type: "normal"
- });
- const session = {
- windowId: win.id,
- idleTimer: null,
- idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
- owned: true,
- preferredTabId: null
- };
- automationSessions.set(workspace, session);
- console.log(`[opencli] Created automation window ${session.windowId} (${workspace}, start=${startUrl})`);
- resetWindowIdleTimer(workspace);
- const tabs = await chrome.tabs.query({ windowId: win.id });
- if (tabs[0]?.id) {
- await new Promise((resolve) => {
- const timeout = setTimeout(resolve, 500);
- const listener = (tabId, info) => {
- if (tabId === tabs[0].id && info.status === "complete") {
- chrome.tabs.onUpdated.removeListener(listener);
- clearTimeout(timeout);
- resolve();
- }
- };
- if (tabs[0].status === "complete") {
- clearTimeout(timeout);
- resolve();
- } else {
- chrome.tabs.onUpdated.addListener(listener);
- }
- });
- }
- return session.windowId;
-}
-chrome.windows.onRemoved.addListener((windowId) => {
- for (const [workspace, session] of automationSessions.entries()) {
- if (session.windowId === windowId) {
- console.log(`[opencli] Automation window closed (${workspace})`);
- if (session.idleTimer) clearTimeout(session.idleTimer);
- automationSessions.delete(workspace);
- }
- }
+ const existing = automationSessions.get(workspace);
+ if (existing) try {
+ await chrome.windows.get(existing.windowId);
+ return existing.windowId;
+ } catch {
+ automationSessions.delete(workspace);
+ }
+ const startUrl = initialUrl && isSafeNavigationUrl(initialUrl) ? initialUrl : BLANK_PAGE;
+ const win = await chrome.windows.create({
+ url: startUrl,
+ focused: windowFocused,
+ width: 1280,
+ height: 900,
+ type: "normal"
+ });
+ const session = {
+ windowId: win.id,
+ idleTimer: null,
+ idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+ owned: true,
+ preferredTabId: null
+ };
+ automationSessions.set(workspace, session);
+ console.log(`[opencli] Created automation window ${session.windowId} (${workspace}, start=${startUrl})`);
+ resetWindowIdleTimer(workspace);
+ const tabs = await chrome.tabs.query({ windowId: win.id });
+ if (tabs[0]?.id) await new Promise((resolve) => {
+ const timeout = setTimeout(resolve, 500);
+ const listener = (tabId, info) => {
+ if (tabId === tabs[0].id && info.status === "complete") {
+ chrome.tabs.onUpdated.removeListener(listener);
+ clearTimeout(timeout);
+ resolve();
+ }
+ };
+ if (tabs[0].status === "complete") {
+ clearTimeout(timeout);
+ resolve();
+ } else chrome.tabs.onUpdated.addListener(listener);
+ });
+ return session.windowId;
+}
+chrome.windows.onRemoved.addListener(async (windowId) => {
+ for (const [workspace, session] of automationSessions.entries()) if (session.windowId === windowId) {
+ console.log(`[opencli] Automation window closed (${workspace})`);
+ if (session.idleTimer) clearTimeout(session.idleTimer);
+ automationSessions.delete(workspace);
+ }
+});
+chrome.tabs.onRemoved.addListener((tabId) => {
+ evictTab(tabId);
});
-let initialized = false;
+var initialized = false;
function initialize() {
- if (initialized) return;
- initialized = true;
- chrome.alarms.create("keepalive", { periodInMinutes: 0.4 });
- registerListeners();
- void connect();
- console.log("[opencli] OpenCLI extension initialized");
+ if (initialized) return;
+ initialized = true;
+ chrome.alarms.create("keepalive", { periodInMinutes: .4 });
+ registerListeners();
+ connect();
+ console.log("[opencli] OpenCLI extension initialized");
}
chrome.runtime.onInstalled.addListener(() => {
- initialize();
+ initialize();
});
chrome.runtime.onStartup.addListener(() => {
- initialize();
+ initialize();
});
chrome.alarms.onAlarm.addListener((alarm) => {
- if (alarm.name === "keepalive") void connect();
+ if (alarm.name === "keepalive") connect();
});
chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
- if (msg?.type === "getStatus") {
- sendResponse({
- connected: ws?.readyState === WebSocket.OPEN,
- reconnecting: reconnectTimer !== null
- });
- }
- return false;
+ if (msg?.type === "getStatus") sendResponse({
+ connected: ws?.readyState === WebSocket.OPEN,
+ reconnecting: reconnectTimer !== null
+ });
+ else if (msg?.type === "getPageState") {
+ handleGetPageState().then((result) => {
+ sendResponse(result);
+ }).catch((err) => {
+ sendResponse({
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ });
+ });
+ return true;
+ }
+ return false;
+});
+chrome.commands.onCommand.addListener((command) => {
+ if (command === "get-page-state") handleGetPageState().then((result) => {
+ if (result.ok) chrome.notifications.create("opencli-page-state", {
+ type: "basic",
+ title: "OpenCLI",
+ message: "Page state captured successfully",
+ iconUrl: "icons/icon-48.png"
+ });
+ else chrome.notifications.create("opencli-page-state-error", {
+ type: "basic",
+ title: "OpenCLI Error",
+ message: `Failed to capture page state: ${result.error}`,
+ iconUrl: "icons/icon-48.png"
+ });
+ });
});
+async function handleGetPageState() {
+ const workspace = "browser:default";
+ try {
+ const activeTabs = await chrome.tabs.query({
+ active: true,
+ lastFocusedWindow: true
+ });
+ const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+ const allTabs = await chrome.tabs.query({});
+ const boundTab = activeTabs.find((tab) => tab.id && (tab.url?.startsWith("http://") || tab.url?.startsWith("https://"))) ?? fallbackTabs.find((tab) => tab.id && (tab.url?.startsWith("http://") || tab.url?.startsWith("https://"))) ?? allTabs.find((tab) => tab.id && (tab.url?.startsWith("http://") || tab.url?.startsWith("https://")));
+ if (!boundTab?.id) return {
+ id: "popup-state",
+ ok: false,
+ error: "No active debuggable tab found"
+ };
+ setWorkspaceSession(workspace, {
+ windowId: boundTab.windowId,
+ owned: false,
+ preferredTabId: boundTab.id
+ });
+ resetWindowIdleTimer(workspace);
+ const snapshotJs = generateSnapshotJs({
+ viewportExpand: 2e3,
+ maxDepth: 50,
+ interactiveOnly: false,
+ maxTextLength: 120,
+ includeScrollInfo: true,
+ bboxDedup: true,
+ includeShadowDom: true,
+ includeIframes: true,
+ maxIframes: 5,
+ paintOrderCheck: true,
+ annotateRefs: true,
+ reportHidden: true,
+ filterAds: true,
+ markdownTables: true,
+ previousHashes: null
+ });
+ const aggressive = workspace.startsWith("browser:") || workspace.startsWith("operate:");
+ const data = await evaluateAsync(boundTab.id, snapshotJs, aggressive);
+ const markElementsScript = `
+ (() => {
+ 'use strict';
+
+ // 移除之前的标记
+ document.querySelectorAll('.opencli-element-mark').forEach(el => el.remove());
+
+ // 遍历所有带有 data-opencli-ref 属性的元素
+ document.querySelectorAll('[data-opencli-ref]').forEach(el => {
+ try {
+ const rect = el.getBoundingClientRect();
+ const ref = el.getAttribute('data-opencli-ref');
+
+ if (rect.width > 0 && rect.height > 0 && ref) {
+ // 创建标记元素
+ const mark = document.createElement('div');
+ mark.className = 'opencli-element-mark';
+ mark.textContent = ref;
+ mark.style.position = 'absolute';
+ mark.style.left = '0';
+ mark.style.top = '0';
+ mark.style.transform = 'translate(-50%, -50%)';
+ mark.style.background = 'rgba(255, 0, 0, 0.8)';
+ mark.style.color = 'white';
+ mark.style.fontSize = '12px';
+ mark.style.fontWeight = 'bold';
+ mark.style.padding = '2px 6px';
+ mark.style.borderRadius = '10px';
+ mark.style.zIndex = '9999';
+ mark.style.pointerEvents = 'none';
+ mark.style.boxShadow = '0 2px 4px rgba(0, 0, 0, 0.3)';
+
+ // 计算中心位置
+ const centerX = rect.left + rect.width / 2;
+ const centerY = rect.top + rect.height / 2;
+
+ // 设置位置
+ mark.style.left = centerX + 'px';
+ mark.style.top = centerY + 'px';
+
+ // 添加到文档
+ document.body.appendChild(mark);
+ }
+ } catch (e) {
+ // 忽略错误
+ }
+ });
+ })()
+ `;
+ try {
+ await evaluateAsync(boundTab.id, markElementsScript, aggressive);
+ } catch (err) {}
+ return {
+ id: "popup-state",
+ ok: true,
+ data
+ };
+ } catch (err) {
+ return {
+ id: "popup-state",
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
+}
async function handleCommand(cmd) {
- const workspace = getWorkspaceKey(cmd.workspace);
- resetWindowIdleTimer(workspace);
- try {
- switch (cmd.action) {
- case "exec":
- return await handleExec(cmd, workspace);
- case "navigate":
- return await handleNavigate(cmd, workspace);
- case "tabs":
- return await handleTabs(cmd, workspace);
- case "cookies":
- return await handleCookies(cmd);
- case "screenshot":
- return await handleScreenshot(cmd, workspace);
- case "close-window":
- return await handleCloseWindow(cmd, workspace);
- case "cdp":
- return await handleCdp(cmd, workspace);
- case "sessions":
- return await handleSessions(cmd);
- case "set-file-input":
- return await handleSetFileInput(cmd, workspace);
- case "insert-text":
- return await handleInsertText(cmd, workspace);
- case "bind-current":
- return await handleBindCurrent(cmd, workspace);
- case "network-capture-start":
- return await handleNetworkCaptureStart(cmd, workspace);
- case "network-capture-read":
- return await handleNetworkCaptureRead(cmd, workspace);
- default:
- return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
- }
- } catch (err) {
- return {
- id: cmd.id,
- ok: false,
- error: err instanceof Error ? err.message : String(err)
- };
- }
+ const workspace = getWorkspaceKey(cmd.workspace);
+ windowFocused = cmd.windowFocused === true;
+ resetWindowIdleTimer(workspace);
+ try {
+ switch (cmd.action) {
+ case "exec": return await handleExec(cmd, workspace);
+ case "navigate": return await handleNavigate(cmd, workspace);
+ case "tabs": return await handleTabs(cmd, workspace);
+ case "cookies": return await handleCookies(cmd);
+ case "screenshot": return await handleScreenshot(cmd, workspace);
+ case "close-window": return await handleCloseWindow(cmd, workspace);
+ case "cdp": return await handleCdp(cmd, workspace);
+ case "sessions": return await handleSessions(cmd);
+ case "set-file-input": return await handleSetFileInput(cmd, workspace);
+ case "insert-text": return await handleInsertText(cmd, workspace);
+ case "bind-current": return await handleBindCurrent(cmd, workspace);
+ case "network-capture-start": return await handleNetworkCaptureStart(cmd, workspace);
+ case "network-capture-read": return await handleNetworkCaptureRead(cmd, workspace);
+ default: return {
+ id: cmd.id,
+ ok: false,
+ error: `Unknown action: ${cmd.action}`
+ };
+ }
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
-const BLANK_PAGE = "about:blank";
+/** Internal blank page used when no user URL is provided. */
+var BLANK_PAGE = "about:blank";
+/** Check if a URL can be attached via CDP — only allow http(s) and blank pages. */
function isDebuggableUrl(url) {
- if (!url) return true;
- return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
+ if (!url) return true;
+ return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
}
+/** Check if a URL is safe for user-facing navigation (http/https only). */
function isSafeNavigationUrl(url) {
- return url.startsWith("http://") || url.startsWith("https://");
+ return url.startsWith("http://") || url.startsWith("https://");
}
+/** Minimal URL normalization for same-page comparison: root slash + default port only. */
function normalizeUrlForComparison(url) {
- if (!url) return "";
- try {
- const parsed = new URL(url);
- if (parsed.protocol === "https:" && parsed.port === "443" || parsed.protocol === "http:" && parsed.port === "80") {
- parsed.port = "";
- }
- const pathname = parsed.pathname === "/" ? "" : parsed.pathname;
- return `${parsed.protocol}//${parsed.host}${pathname}${parsed.search}${parsed.hash}`;
- } catch {
- return url;
- }
+ if (!url) return "";
+ try {
+ const parsed = new URL(url);
+ if (parsed.protocol === "https:" && parsed.port === "443" || parsed.protocol === "http:" && parsed.port === "80") parsed.port = "";
+ const pathname = parsed.pathname === "/" ? "" : parsed.pathname;
+ return `${parsed.protocol}//${parsed.host}${pathname}${parsed.search}${parsed.hash}`;
+ } catch {
+ return url;
+ }
}
function isTargetUrl(currentUrl, targetUrl) {
- return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(targetUrl);
+ return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(targetUrl);
}
function matchesDomain(url, domain) {
- if (!url) return false;
- try {
- const parsed = new URL(url);
- return parsed.hostname === domain || parsed.hostname.endsWith(`.${domain}`);
- } catch {
- return false;
- }
+ if (!url) return false;
+ try {
+ const parsed = new URL(url);
+ return parsed.hostname === domain || parsed.hostname.endsWith(`.${domain}`);
+ } catch {
+ return false;
+ }
}
function matchesBindCriteria(tab, cmd) {
- if (!tab.id || !isDebuggableUrl(tab.url)) return false;
- if (cmd.matchDomain && !matchesDomain(tab.url, cmd.matchDomain)) return false;
- if (cmd.matchPathPrefix) {
- try {
- const parsed = new URL(tab.url);
- if (!parsed.pathname.startsWith(cmd.matchPathPrefix)) return false;
- } catch {
- return false;
- }
- }
- return true;
+ if (!tab.id || !isDebuggableUrl(tab.url)) return false;
+ if (cmd.matchDomain && !matchesDomain(tab.url, cmd.matchDomain)) return false;
+ if (cmd.matchPathPrefix) try {
+ if (!new URL(tab.url).pathname.startsWith(cmd.matchPathPrefix)) return false;
+ } catch {
+ return false;
+ }
+ return true;
}
function setWorkspaceSession(workspace, session) {
- const existing = automationSessions.get(workspace);
- if (existing?.idleTimer) clearTimeout(existing.idleTimer);
- automationSessions.set(workspace, {
- ...session,
- idleTimer: null,
- idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT
- });
+ const existing = automationSessions.get(workspace);
+ if (existing?.idleTimer) clearTimeout(existing.idleTimer);
+ automationSessions.set(workspace, {
+ ...session,
+ idleTimer: null,
+ idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT
+ });
}
+/**
+* Resolve tabId from command's page (targetId) or legacy tabId field.
+* page (targetId) takes precedence. Returns undefined if neither is provided.
+*/
+async function resolveCommandTabId(cmd) {
+ if (cmd.page) return resolveTabId$1(cmd.page);
+ return cmd.tabId;
+}
+/**
+* Resolve target tab in the automation window, returning both the tabId and
+* the Tab object (when available) so callers can skip a redundant chrome.tabs.get().
+*/
async function resolveTab(tabId, workspace, initialUrl) {
- if (tabId !== void 0) {
- try {
- const tab = await chrome.tabs.get(tabId);
- const session = automationSessions.get(workspace);
- const matchesSession = session ? session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId : false;
- if (isDebuggableUrl(tab.url) && matchesSession) return { tabId, tab };
- if (session && !matchesSession && session.preferredTabId === null && isDebuggableUrl(tab.url)) {
- console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId}, moving back to ${session.windowId}`);
- try {
- await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
- const moved = await chrome.tabs.get(tabId);
- if (moved.windowId === session.windowId && isDebuggableUrl(moved.url)) {
- return { tabId, tab: moved };
- }
- } catch (moveErr) {
- console.warn(`[opencli] Failed to move tab back: ${moveErr}`);
- }
- } else if (!isDebuggableUrl(tab.url)) {
- console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
- }
- } catch {
- console.warn(`[opencli] Tab ${tabId} no longer exists, re-resolving`);
- }
- }
- const existingSession = automationSessions.get(workspace);
- if (existingSession?.preferredTabId !== null) {
- try {
- const preferredTab = await chrome.tabs.get(existingSession.preferredTabId);
- if (isDebuggableUrl(preferredTab.url)) return { tabId: preferredTab.id, tab: preferredTab };
- } catch {
- automationSessions.delete(workspace);
- }
- }
- const windowId = await getAutomationWindow(workspace, initialUrl);
- const tabs = await chrome.tabs.query({ windowId });
- const debuggableTab = tabs.find((t) => t.id && isDebuggableUrl(t.url));
- if (debuggableTab?.id) return { tabId: debuggableTab.id, tab: debuggableTab };
- const reuseTab = tabs.find((t) => t.id);
- if (reuseTab?.id) {
- await chrome.tabs.update(reuseTab.id, { url: BLANK_PAGE });
- await new Promise((resolve) => setTimeout(resolve, 300));
- try {
- const updated = await chrome.tabs.get(reuseTab.id);
- if (isDebuggableUrl(updated.url)) return { tabId: reuseTab.id, tab: updated };
- console.warn(`[opencli] data: URI was intercepted (${updated.url}), creating fresh tab`);
- } catch {
- }
- }
- const newTab = await chrome.tabs.create({ windowId, url: BLANK_PAGE, active: true });
- if (!newTab.id) throw new Error("Failed to create tab in automation window");
- return { tabId: newTab.id, tab: newTab };
+ if (tabId !== void 0) try {
+ const tab = await chrome.tabs.get(tabId);
+ const session = automationSessions.get(workspace);
+ const matchesSession = session ? session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId : false;
+ if (isDebuggableUrl(tab.url) && matchesSession) return {
+ tabId,
+ tab
+ };
+ if (session && !matchesSession && session.preferredTabId === null && isDebuggableUrl(tab.url)) {
+ console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId}, moving back to ${session.windowId}`);
+ try {
+ await chrome.tabs.move(tabId, {
+ windowId: session.windowId,
+ index: -1
+ });
+ const moved = await chrome.tabs.get(tabId);
+ if (moved.windowId === session.windowId && isDebuggableUrl(moved.url)) return {
+ tabId,
+ tab: moved
+ };
+ } catch (moveErr) {
+ console.warn(`[opencli] Failed to move tab back: ${moveErr}`);
+ }
+ } else if (!isDebuggableUrl(tab.url)) console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
+ } catch {
+ console.warn(`[opencli] Tab ${tabId} no longer exists, re-resolving`);
+ }
+ const existingSession = automationSessions.get(workspace);
+ if (existingSession?.preferredTabId !== null) try {
+ const preferredTab = await chrome.tabs.get(existingSession.preferredTabId);
+ if (isDebuggableUrl(preferredTab.url)) return {
+ tabId: preferredTab.id,
+ tab: preferredTab
+ };
+ } catch {
+ automationSessions.delete(workspace);
+ }
+ const windowId = await getAutomationWindow(workspace, initialUrl);
+ const tabs = await chrome.tabs.query({ windowId });
+ const debuggableTab = tabs.find((t) => t.id && isDebuggableUrl(t.url));
+ if (debuggableTab?.id) return {
+ tabId: debuggableTab.id,
+ tab: debuggableTab
+ };
+ const reuseTab = tabs.find((t) => t.id);
+ if (reuseTab?.id) {
+ await chrome.tabs.update(reuseTab.id, { url: BLANK_PAGE });
+ await new Promise((resolve) => setTimeout(resolve, 300));
+ try {
+ const updated = await chrome.tabs.get(reuseTab.id);
+ if (isDebuggableUrl(updated.url)) return {
+ tabId: reuseTab.id,
+ tab: updated
+ };
+ console.warn(`[opencli] data: URI was intercepted (${updated.url}), creating fresh tab`);
+ } catch {}
+ }
+ const newTab = await chrome.tabs.create({
+ windowId,
+ url: BLANK_PAGE,
+ active: true
+ });
+ if (!newTab.id) throw new Error("Failed to create tab in automation window");
+ return {
+ tabId: newTab.id,
+ tab: newTab
+ };
+}
+/** Build a page-scoped success result with targetId resolved from tabId */
+async function pageScopedResult(id, tabId, data) {
+ return {
+ id,
+ ok: true,
+ data,
+ page: await resolveTargetId(tabId)
+ };
}
+/** Convenience wrapper returning just the tabId (used by most handlers) */
async function resolveTabId(tabId, workspace, initialUrl) {
- const resolved = await resolveTab(tabId, workspace, initialUrl);
- return resolved.tabId;
+ return (await resolveTab(tabId, workspace, initialUrl)).tabId;
}
async function listAutomationTabs(workspace) {
- const session = automationSessions.get(workspace);
- if (!session) return [];
- if (session.preferredTabId !== null) {
- try {
- return [await chrome.tabs.get(session.preferredTabId)];
- } catch {
- automationSessions.delete(workspace);
- return [];
- }
- }
- try {
- return await chrome.tabs.query({ windowId: session.windowId });
- } catch {
- automationSessions.delete(workspace);
- return [];
- }
+ const session = automationSessions.get(workspace);
+ if (!session) return [];
+ if (session.preferredTabId !== null) try {
+ return [await chrome.tabs.get(session.preferredTabId)];
+ } catch {
+ automationSessions.delete(workspace);
+ return [];
+ }
+ try {
+ return await chrome.tabs.query({ windowId: session.windowId });
+ } catch {
+ automationSessions.delete(workspace);
+ return [];
+ }
}
async function listAutomationWebTabs(workspace) {
- const tabs = await listAutomationTabs(workspace);
- return tabs.filter((tab) => isDebuggableUrl(tab.url));
+ return (await listAutomationTabs(workspace)).filter((tab) => isDebuggableUrl(tab.url));
}
async function handleExec(cmd, workspace) {
- if (!cmd.code) return { id: cmd.id, ok: false, error: "Missing code" };
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- const aggressive = workspace.startsWith("operate:");
- const data = await evaluateAsync(tabId, cmd.code, aggressive);
- return { id: cmd.id, ok: true, data };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ if (!cmd.code) return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing code"
+ };
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ const aggressive = workspace.startsWith("browser:") || workspace.startsWith("operate:");
+ const data = await evaluateAsync(tabId, cmd.code, aggressive);
+ return pageScopedResult(cmd.id, tabId, data);
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleNavigate(cmd, workspace) {
- if (!cmd.url) return { id: cmd.id, ok: false, error: "Missing url" };
- if (!isSafeNavigationUrl(cmd.url)) {
- return { id: cmd.id, ok: false, error: "Blocked URL scheme -- only http:// and https:// are allowed" };
- }
- const resolved = await resolveTab(cmd.tabId, workspace, cmd.url);
- const tabId = resolved.tabId;
- const beforeTab = resolved.tab ?? await chrome.tabs.get(tabId);
- const beforeNormalized = normalizeUrlForComparison(beforeTab.url);
- const targetUrl = cmd.url;
- if (beforeTab.status === "complete" && isTargetUrl(beforeTab.url, targetUrl)) {
- return {
- id: cmd.id,
- ok: true,
- data: { title: beforeTab.title, url: beforeTab.url, tabId, timedOut: false }
- };
- }
- await detach(tabId);
- await chrome.tabs.update(tabId, { url: targetUrl });
- let timedOut = false;
- await new Promise((resolve) => {
- let settled = false;
- let checkTimer = null;
- let timeoutTimer = null;
- const finish = () => {
- if (settled) return;
- settled = true;
- chrome.tabs.onUpdated.removeListener(listener);
- if (checkTimer) clearTimeout(checkTimer);
- if (timeoutTimer) clearTimeout(timeoutTimer);
- resolve();
- };
- const isNavigationDone = (url) => {
- return isTargetUrl(url, targetUrl) || normalizeUrlForComparison(url) !== beforeNormalized;
- };
- const listener = (id, info, tab2) => {
- if (id !== tabId) return;
- if (info.status === "complete" && isNavigationDone(tab2.url ?? info.url)) {
- finish();
- }
- };
- chrome.tabs.onUpdated.addListener(listener);
- checkTimer = setTimeout(async () => {
- try {
- const currentTab = await chrome.tabs.get(tabId);
- if (currentTab.status === "complete" && isNavigationDone(currentTab.url)) {
- finish();
- }
- } catch {
- }
- }, 100);
- timeoutTimer = setTimeout(() => {
- timedOut = true;
- console.warn(`[opencli] Navigate to ${targetUrl} timed out after 15s`);
- finish();
- }, 15e3);
- });
- let tab = await chrome.tabs.get(tabId);
- const session = automationSessions.get(workspace);
- if (session && tab.windowId !== session.windowId) {
- console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId} during navigation, moving back to ${session.windowId}`);
- try {
- await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
- tab = await chrome.tabs.get(tabId);
- } catch (moveErr) {
- console.warn(`[opencli] Failed to recover drifted tab: ${moveErr}`);
- }
- }
- return {
- id: cmd.id,
- ok: true,
- data: { title: tab.title, url: tab.url, tabId, timedOut }
- };
+ if (!cmd.url) return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing url"
+ };
+ if (!isSafeNavigationUrl(cmd.url)) return {
+ id: cmd.id,
+ ok: false,
+ error: "Blocked URL scheme -- only http:// and https:// are allowed"
+ };
+ const resolved = await resolveTab(await resolveCommandTabId(cmd), workspace, cmd.url);
+ const tabId = resolved.tabId;
+ const beforeTab = resolved.tab ?? await chrome.tabs.get(tabId);
+ const beforeNormalized = normalizeUrlForComparison(beforeTab.url);
+ const targetUrl = cmd.url;
+ if (beforeTab.status === "complete" && isTargetUrl(beforeTab.url, targetUrl)) return pageScopedResult(cmd.id, tabId, {
+ title: beforeTab.title,
+ url: beforeTab.url,
+ timedOut: false
+ });
+ await detach(tabId);
+ await chrome.tabs.update(tabId, { url: targetUrl });
+ let timedOut = false;
+ await new Promise((resolve) => {
+ let settled = false;
+ let checkTimer = null;
+ let timeoutTimer = null;
+ const finish = () => {
+ if (settled) return;
+ settled = true;
+ chrome.tabs.onUpdated.removeListener(listener);
+ if (checkTimer) clearTimeout(checkTimer);
+ if (timeoutTimer) clearTimeout(timeoutTimer);
+ resolve();
+ };
+ const isNavigationDone = (url) => {
+ return isTargetUrl(url, targetUrl) || normalizeUrlForComparison(url) !== beforeNormalized;
+ };
+ const listener = (id, info, tab) => {
+ if (id !== tabId) return;
+ if (info.status === "complete" && isNavigationDone(tab.url ?? info.url)) finish();
+ };
+ chrome.tabs.onUpdated.addListener(listener);
+ checkTimer = setTimeout(async () => {
+ try {
+ const currentTab = await chrome.tabs.get(tabId);
+ if (currentTab.status === "complete" && isNavigationDone(currentTab.url)) finish();
+ } catch {}
+ }, 100);
+ timeoutTimer = setTimeout(() => {
+ timedOut = true;
+ console.warn(`[opencli] Navigate to ${targetUrl} timed out after 15s`);
+ finish();
+ }, 15e3);
+ });
+ let tab = await chrome.tabs.get(tabId);
+ const session = automationSessions.get(workspace);
+ if (session && tab.windowId !== session.windowId) {
+ console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId} during navigation, moving back to ${session.windowId}`);
+ try {
+ await chrome.tabs.move(tabId, {
+ windowId: session.windowId,
+ index: -1
+ });
+ tab = await chrome.tabs.get(tabId);
+ } catch (moveErr) {
+ console.warn(`[opencli] Failed to recover drifted tab: ${moveErr}`);
+ }
+ }
+ return pageScopedResult(cmd.id, tabId, {
+ title: tab.title,
+ url: tab.url,
+ timedOut
+ });
}
async function handleTabs(cmd, workspace) {
- switch (cmd.op) {
- case "list": {
- const tabs = await listAutomationWebTabs(workspace);
- const data = tabs.map((t, i) => ({
- index: i,
- tabId: t.id,
- url: t.url,
- title: t.title,
- active: t.active
- }));
- return { id: cmd.id, ok: true, data };
- }
- case "new": {
- if (cmd.url && !isSafeNavigationUrl(cmd.url)) {
- return { id: cmd.id, ok: false, error: "Blocked URL scheme -- only http:// and https:// are allowed" };
- }
- const windowId = await getAutomationWindow(workspace);
- const tab = await chrome.tabs.create({ windowId, url: cmd.url ?? BLANK_PAGE, active: true });
- return { id: cmd.id, ok: true, data: { tabId: tab.id, url: tab.url } };
- }
- case "close": {
- if (cmd.index !== void 0) {
- const tabs = await listAutomationWebTabs(workspace);
- const target = tabs[cmd.index];
- if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
- await chrome.tabs.remove(target.id);
- await detach(target.id);
- return { id: cmd.id, ok: true, data: { closed: target.id } };
- }
- const tabId = await resolveTabId(cmd.tabId, workspace);
- await chrome.tabs.remove(tabId);
- await detach(tabId);
- return { id: cmd.id, ok: true, data: { closed: tabId } };
- }
- case "select": {
- if (cmd.index === void 0 && cmd.tabId === void 0)
- return { id: cmd.id, ok: false, error: "Missing index or tabId" };
- if (cmd.tabId !== void 0) {
- const session = automationSessions.get(workspace);
- let tab;
- try {
- tab = await chrome.tabs.get(cmd.tabId);
- } catch {
- return { id: cmd.id, ok: false, error: `Tab ${cmd.tabId} no longer exists` };
- }
- if (!session || tab.windowId !== session.windowId) {
- return { id: cmd.id, ok: false, error: `Tab ${cmd.tabId} is not in the automation window` };
- }
- await chrome.tabs.update(cmd.tabId, { active: true });
- return { id: cmd.id, ok: true, data: { selected: cmd.tabId } };
- }
- const tabs = await listAutomationWebTabs(workspace);
- const target = tabs[cmd.index];
- if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
- await chrome.tabs.update(target.id, { active: true });
- return { id: cmd.id, ok: true, data: { selected: target.id } };
- }
- default:
- return { id: cmd.id, ok: false, error: `Unknown tabs op: ${cmd.op}` };
- }
+ switch (cmd.op) {
+ case "list": {
+ const tabs = await listAutomationWebTabs(workspace);
+ const data = await Promise.all(tabs.map(async (t, i) => {
+ let page;
+ try {
+ page = t.id ? await resolveTargetId(t.id) : void 0;
+ } catch {}
+ return {
+ index: i,
+ page,
+ url: t.url,
+ title: t.title,
+ active: t.active
+ };
+ }));
+ return {
+ id: cmd.id,
+ ok: true,
+ data
+ };
+ }
+ case "new": {
+ if (cmd.url && !isSafeNavigationUrl(cmd.url)) return {
+ id: cmd.id,
+ ok: false,
+ error: "Blocked URL scheme -- only http:// and https:// are allowed"
+ };
+ const windowId = await getAutomationWindow(workspace);
+ const tab = await chrome.tabs.create({
+ windowId,
+ url: cmd.url ?? BLANK_PAGE,
+ active: true
+ });
+ if (!tab.id) return {
+ id: cmd.id,
+ ok: false,
+ error: "Failed to create tab"
+ };
+ return pageScopedResult(cmd.id, tab.id, { url: tab.url });
+ }
+ case "close": {
+ if (cmd.index !== void 0) {
+ const target = (await listAutomationWebTabs(workspace))[cmd.index];
+ if (!target?.id) return {
+ id: cmd.id,
+ ok: false,
+ error: `Tab index ${cmd.index} not found`
+ };
+ const closedPage = await resolveTargetId(target.id).catch(() => void 0);
+ await chrome.tabs.remove(target.id);
+ await detach(target.id);
+ return {
+ id: cmd.id,
+ ok: true,
+ data: { closed: closedPage }
+ };
+ }
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ const closedPage = await resolveTargetId(tabId).catch(() => void 0);
+ await chrome.tabs.remove(tabId);
+ await detach(tabId);
+ return {
+ id: cmd.id,
+ ok: true,
+ data: { closed: closedPage }
+ };
+ }
+ case "select": {
+ if (cmd.index === void 0 && cmd.page === void 0 && cmd.tabId === void 0) return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing index or page"
+ };
+ const cmdTabId = await resolveCommandTabId(cmd);
+ if (cmdTabId !== void 0) {
+ const session = automationSessions.get(workspace);
+ let tab;
+ try {
+ tab = await chrome.tabs.get(cmdTabId);
+ } catch {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: `Page no longer exists`
+ };
+ }
+ if (!session || tab.windowId !== session.windowId) return {
+ id: cmd.id,
+ ok: false,
+ error: `Page is not in the automation window`
+ };
+ await chrome.tabs.update(cmdTabId, { active: true });
+ return pageScopedResult(cmd.id, cmdTabId, { selected: true });
+ }
+ const target = (await listAutomationWebTabs(workspace))[cmd.index];
+ if (!target?.id) return {
+ id: cmd.id,
+ ok: false,
+ error: `Tab index ${cmd.index} not found`
+ };
+ await chrome.tabs.update(target.id, { active: true });
+ return pageScopedResult(cmd.id, target.id, { selected: true });
+ }
+ default: return {
+ id: cmd.id,
+ ok: false,
+ error: `Unknown tabs op: ${cmd.op}`
+ };
+ }
}
async function handleCookies(cmd) {
- if (!cmd.domain && !cmd.url) {
- return { id: cmd.id, ok: false, error: "Cookie scope required: provide domain or url to avoid dumping all cookies" };
- }
- const details = {};
- if (cmd.domain) details.domain = cmd.domain;
- if (cmd.url) details.url = cmd.url;
- const cookies = await chrome.cookies.getAll(details);
- const data = cookies.map((c) => ({
- name: c.name,
- value: c.value,
- domain: c.domain,
- path: c.path,
- secure: c.secure,
- httpOnly: c.httpOnly,
- expirationDate: c.expirationDate
- }));
- return { id: cmd.id, ok: true, data };
+ if (!cmd.domain && !cmd.url) return {
+ id: cmd.id,
+ ok: false,
+ error: "Cookie scope required: provide domain or url to avoid dumping all cookies"
+ };
+ const details = {};
+ if (cmd.domain) details.domain = cmd.domain;
+ if (cmd.url) details.url = cmd.url;
+ const data = (await chrome.cookies.getAll(details)).map((c) => ({
+ name: c.name,
+ value: c.value,
+ domain: c.domain,
+ path: c.path,
+ secure: c.secure,
+ httpOnly: c.httpOnly,
+ expirationDate: c.expirationDate
+ }));
+ return {
+ id: cmd.id,
+ ok: true,
+ data
+ };
}
async function handleScreenshot(cmd, workspace) {
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- const data = await screenshot(tabId, {
- format: cmd.format,
- quality: cmd.quality,
- fullPage: cmd.fullPage
- });
- return { id: cmd.id, ok: true, data };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ const data = await screenshot(tabId, {
+ format: cmd.format,
+ quality: cmd.quality,
+ fullPage: cmd.fullPage
+ });
+ return pageScopedResult(cmd.id, tabId, data);
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
-const CDP_ALLOWLIST = /* @__PURE__ */ new Set([
- // Agent DOM context
- "Accessibility.getFullAXTree",
- "DOM.getDocument",
- "DOM.getBoxModel",
- "DOM.getContentQuads",
- "DOM.querySelectorAll",
- "DOM.scrollIntoViewIfNeeded",
- "DOMSnapshot.captureSnapshot",
- // Native input events
- "Input.dispatchMouseEvent",
- "Input.dispatchKeyEvent",
- "Input.insertText",
- // Page metrics & screenshots
- "Page.getLayoutMetrics",
- "Page.captureScreenshot",
- // Runtime.enable needed for CDP attach setup (Runtime.evaluate goes through 'exec' action)
- "Runtime.enable",
- // Emulation (used by screenshot full-page)
- "Emulation.setDeviceMetricsOverride",
- "Emulation.clearDeviceMetricsOverride"
+/** CDP methods permitted via the 'cdp' passthrough action. */
+var CDP_ALLOWLIST = new Set([
+ "Accessibility.getFullAXTree",
+ "DOM.getDocument",
+ "DOM.getBoxModel",
+ "DOM.getContentQuads",
+ "DOM.querySelectorAll",
+ "DOM.scrollIntoViewIfNeeded",
+ "DOMSnapshot.captureSnapshot",
+ "Input.dispatchMouseEvent",
+ "Input.dispatchKeyEvent",
+ "Input.insertText",
+ "Page.getLayoutMetrics",
+ "Page.captureScreenshot",
+ "Runtime.enable",
+ "Emulation.setDeviceMetricsOverride",
+ "Emulation.clearDeviceMetricsOverride"
]);
async function handleCdp(cmd, workspace) {
- if (!cmd.cdpMethod) return { id: cmd.id, ok: false, error: "Missing cdpMethod" };
- if (!CDP_ALLOWLIST.has(cmd.cdpMethod)) {
- return { id: cmd.id, ok: false, error: `CDP method not permitted: ${cmd.cdpMethod}` };
- }
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- const aggressive = workspace.startsWith("operate:");
- await ensureAttached(tabId, aggressive);
- const data = await chrome.debugger.sendCommand(
- { tabId },
- cmd.cdpMethod,
- cmd.cdpParams ?? {}
- );
- return { id: cmd.id, ok: true, data };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ if (!cmd.cdpMethod) return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing cdpMethod"
+ };
+ if (!CDP_ALLOWLIST.has(cmd.cdpMethod)) return {
+ id: cmd.id,
+ ok: false,
+ error: `CDP method not permitted: ${cmd.cdpMethod}`
+ };
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ await ensureAttached(tabId, workspace.startsWith("browser:") || workspace.startsWith("operate:"));
+ const data = await chrome.debugger.sendCommand({ tabId }, cmd.cdpMethod, cmd.cdpParams ?? {});
+ return pageScopedResult(cmd.id, tabId, data);
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleCloseWindow(cmd, workspace) {
- const session = automationSessions.get(workspace);
- if (session) {
- if (session.owned) {
- try {
- await chrome.windows.remove(session.windowId);
- } catch {
- }
- }
- if (session.idleTimer) clearTimeout(session.idleTimer);
- automationSessions.delete(workspace);
- }
- return { id: cmd.id, ok: true, data: { closed: true } };
+ const session = automationSessions.get(workspace);
+ if (session) {
+ if (session.owned) try {
+ await chrome.windows.remove(session.windowId);
+ } catch {}
+ if (session.idleTimer) clearTimeout(session.idleTimer);
+ automationSessions.delete(workspace);
+ }
+ return {
+ id: cmd.id,
+ ok: true,
+ data: { closed: true }
+ };
}
async function handleSetFileInput(cmd, workspace) {
- if (!cmd.files || !Array.isArray(cmd.files) || cmd.files.length === 0) {
- return { id: cmd.id, ok: false, error: "Missing or empty files array" };
- }
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- await setFileInputFiles(tabId, cmd.files, cmd.selector);
- return { id: cmd.id, ok: true, data: { count: cmd.files.length } };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ if (!cmd.files || !Array.isArray(cmd.files) || cmd.files.length === 0) return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing or empty files array"
+ };
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ await setFileInputFiles(tabId, cmd.files, cmd.selector);
+ return pageScopedResult(cmd.id, tabId, { count: cmd.files.length });
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleInsertText(cmd, workspace) {
- if (typeof cmd.text !== "string") {
- return { id: cmd.id, ok: false, error: "Missing text payload" };
- }
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- await insertText(tabId, cmd.text);
- return { id: cmd.id, ok: true, data: { inserted: true } };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ if (typeof cmd.text !== "string") return {
+ id: cmd.id,
+ ok: false,
+ error: "Missing text payload"
+ };
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ await insertText(tabId, cmd.text);
+ return pageScopedResult(cmd.id, tabId, { inserted: true });
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleNetworkCaptureStart(cmd, workspace) {
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- await startNetworkCapture(tabId, cmd.pattern);
- return { id: cmd.id, ok: true, data: { started: true } };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ await startNetworkCapture(tabId, cmd.pattern);
+ return pageScopedResult(cmd.id, tabId, { started: true });
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleNetworkCaptureRead(cmd, workspace) {
- const tabId = await resolveTabId(cmd.tabId, workspace);
- try {
- const data = await readNetworkCapture(tabId);
- return { id: cmd.id, ok: true, data };
- } catch (err) {
- return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
- }
+ const tabId = await resolveTabId(await resolveCommandTabId(cmd), workspace);
+ try {
+ const data = await readNetworkCapture(tabId);
+ return pageScopedResult(cmd.id, tabId, data);
+ } catch (err) {
+ return {
+ id: cmd.id,
+ ok: false,
+ error: err instanceof Error ? err.message : String(err)
+ };
+ }
}
async function handleSessions(cmd) {
- const now = Date.now();
- const data = await Promise.all([...automationSessions.entries()].map(async ([workspace, session]) => ({
- workspace,
- windowId: session.windowId,
- tabCount: (await chrome.tabs.query({ windowId: session.windowId })).filter((tab) => isDebuggableUrl(tab.url)).length,
- idleMsRemaining: Math.max(0, session.idleDeadlineAt - now)
- })));
- return { id: cmd.id, ok: true, data };
+ const now = Date.now();
+ const data = await Promise.all([...automationSessions.entries()].map(async ([workspace, session]) => ({
+ workspace,
+ windowId: session.windowId,
+ tabCount: (await chrome.tabs.query({ windowId: session.windowId })).filter((tab) => isDebuggableUrl(tab.url)).length,
+ idleMsRemaining: Math.max(0, session.idleDeadlineAt - now)
+ })));
+ return {
+ id: cmd.id,
+ ok: true,
+ data
+ };
}
async function handleBindCurrent(cmd, workspace) {
- const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
- const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
- const allTabs = await chrome.tabs.query({});
- const boundTab = activeTabs.find((tab) => matchesBindCriteria(tab, cmd)) ?? fallbackTabs.find((tab) => matchesBindCriteria(tab, cmd)) ?? allTabs.find((tab) => matchesBindCriteria(tab, cmd));
- if (!boundTab?.id) {
- return {
- id: cmd.id,
- ok: false,
- error: cmd.matchDomain || cmd.matchPathPrefix ? `No visible tab matching ${cmd.matchDomain ?? "domain"}${cmd.matchPathPrefix ? ` ${cmd.matchPathPrefix}` : ""}` : "No active debuggable tab found"
- };
- }
- setWorkspaceSession(workspace, {
- windowId: boundTab.windowId,
- owned: false,
- preferredTabId: boundTab.id
- });
- resetWindowIdleTimer(workspace);
- console.log(`[opencli] Workspace ${workspace} explicitly bound to tab ${boundTab.id} (${boundTab.url})`);
- return {
- id: cmd.id,
- ok: true,
- data: {
- tabId: boundTab.id,
- windowId: boundTab.windowId,
- url: boundTab.url,
- title: boundTab.title,
- workspace
- }
- };
+ const activeTabs = await chrome.tabs.query({
+ active: true,
+ lastFocusedWindow: true
+ });
+ const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+ const allTabs = await chrome.tabs.query({});
+ const boundTab = activeTabs.find((tab) => matchesBindCriteria(tab, cmd)) ?? fallbackTabs.find((tab) => matchesBindCriteria(tab, cmd)) ?? allTabs.find((tab) => matchesBindCriteria(tab, cmd));
+ if (!boundTab?.id) return {
+ id: cmd.id,
+ ok: false,
+ error: cmd.matchDomain || cmd.matchPathPrefix ? `No visible tab matching ${cmd.matchDomain ?? "domain"}${cmd.matchPathPrefix ? ` ${cmd.matchPathPrefix}` : ""}` : "No active debuggable tab found"
+ };
+ setWorkspaceSession(workspace, {
+ windowId: boundTab.windowId,
+ owned: false,
+ preferredTabId: boundTab.id
+ });
+ resetWindowIdleTimer(workspace);
+ console.log(`[opencli] Workspace ${workspace} explicitly bound to tab ${boundTab.id} (${boundTab.url})`);
+ return pageScopedResult(cmd.id, boundTab.id, {
+ url: boundTab.url,
+ title: boundTab.title,
+ workspace
+ });
}
+//#endregion
diff --git a/extension/manifest.json b/extension/manifest.json
index 41599886c..fe01105bf 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -34,5 +34,13 @@
"content_security_policy": {
"extension_pages": "script-src 'self'; object-src 'self'"
},
- "homepage_url": "https://github.com/jackwener/opencli"
+ "homepage_url": "https://github.com/jackwener/opencli",
+ "commands": {
+ "get-page-state": {
+ "suggested_key": {
+ "default": "Alt+S"
+ },
+ "description": "Get page state"
+ }
+ }
}
diff --git a/extension/popup.html b/extension/popup.html
index 02ca1b972..5aa1704cd 100644
--- a/extension/popup.html
+++ b/extension/popup.html
@@ -54,6 +54,36 @@
border-radius: 3px;
font-size: 11px;
}
+ .action-button {
+ margin-top: 14px;
+ width: 100%;
+ padding: 10px;
+ background: #007aff;
+ color: white;
+ border: none;
+ border-radius: 8px;
+ font-size: 13px;
+ font-weight: 600;
+ cursor: pointer;
+ }
+ .action-button:hover {
+ background: #0066cc;
+ }
+ .action-button:disabled {
+ background: #cccccc;
+ cursor: not-allowed;
+ }
+ .result {
+ margin-top: 14px;
+ padding: 10px;
+ border-radius: 8px;
+ background: #f5f5f5;
+ font-size: 11px;
+ color: #333;
+ max-height: 200px;
+ overflow-y: auto;
+ display: none;
+ }
.footer {
margin-top: 14px;
text-align: center;
@@ -76,6 +106,8 @@
OpenCLI
This is normal. The extension connects automatically when you run any opencli command.
+
+
diff --git a/extension/popup.js b/extension/popup.js
index 4bd3a7d48..8f2906da5 100644
--- a/extension/popup.js
+++ b/extension/popup.js
@@ -3,23 +3,72 @@ chrome.runtime.sendMessage({ type: 'getStatus' }, (resp) => {
const dot = document.getElementById('dot');
const status = document.getElementById('status');
const hint = document.getElementById('hint');
+ const stateButton = document.getElementById('stateButton');
+
if (chrome.runtime.lastError || !resp) {
dot.className = 'dot disconnected';
status.innerHTML = '
No daemon connected';
hint.style.display = 'block';
+ stateButton.disabled = true;
return;
}
if (resp.connected) {
dot.className = 'dot connected';
status.innerHTML = '
Connected to daemon';
hint.style.display = 'none';
+ stateButton.disabled = false;
} else if (resp.reconnecting) {
dot.className = 'dot connecting';
status.innerHTML = '
Reconnecting...';
hint.style.display = 'none';
+ stateButton.disabled = true;
} else {
dot.className = 'dot disconnected';
status.innerHTML = '
No daemon connected';
hint.style.display = 'block';
+ stateButton.disabled = true;
+ }
+});
+
+// Add event listener for state button
+document.getElementById('stateButton').addEventListener('click', async () => {
+ const resultDiv = document.getElementById('result');
+ const stateButton = document.getElementById('stateButton');
+
+ // Show loading state
+ stateButton.disabled = true;
+ stateButton.textContent = 'Loading...';
+ resultDiv.style.display = 'block';
+ resultDiv.textContent = 'Getting page state...';
+
+ try {
+ // Send message to background script to get page state
+ chrome.runtime.sendMessage({ type: 'getPageState' }, (response) => {
+ if (chrome.runtime.lastError) {
+ resultDiv.textContent = `Error: ${chrome.runtime.lastError.message}`;
+ stateButton.disabled = false;
+ stateButton.textContent = 'Get Page State';
+ return;
+ }
+
+ if (response && response.ok) {
+ // Format the result
+ if (typeof response.data === 'string') {
+ resultDiv.textContent = response.data;
+ } else {
+ resultDiv.textContent = JSON.stringify(response.data, null, 2);
+ }
+ } else {
+ resultDiv.textContent = `Error: ${response?.error || 'Failed to get page state'}`;
+ }
+
+ // Reset button state
+ stateButton.disabled = false;
+ stateButton.textContent = 'Get Page State';
+ });
+ } catch (error) {
+ resultDiv.textContent = `Error: ${error.message}`;
+ stateButton.disabled = false;
+ stateButton.textContent = 'Get Page State';
}
});
diff --git a/extension/src/background.ts b/extension/src/background.ts
index 7e1852af5..a1cb9c5a1 100644
--- a/extension/src/background.ts
+++ b/extension/src/background.ts
@@ -9,6 +9,7 @@ import type { Command, Result } from './protocol';
import { DAEMON_WS_URL, DAEMON_PING_URL, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY } from './protocol';
import * as executor from './cdp';
import * as identity from './identity';
+import { generateSnapshotJs } from '@src/browser/dom-snapshot.js';
let ws: WebSocket | null = null;
let reconnectTimer: ReturnType
| null = null;
@@ -265,10 +266,171 @@ chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
connected: ws?.readyState === WebSocket.OPEN,
reconnecting: reconnectTimer !== null,
});
+ } else if (msg?.type === 'getPageState') {
+ // Handle getPageState message
+ handleGetPageState().then(result => {
+ sendResponse(result);
+ }).catch(err => {
+ sendResponse({
+ ok: false,
+ error: err instanceof Error ? err.message : String(err),
+ });
+ });
+ return true; // Indicates we will send a response asynchronously
}
return false;
});
+// ─── Keyboard Shortcut Listener ────────────────────────────────────
+
+// Listen for keyboard shortcuts
+chrome.commands.onCommand.addListener((command) => {
+ if (command === 'get-page-state') {
+ handleGetPageState().then(result => {
+ // Show notification if needed
+ if (result.ok) {
+ chrome.notifications.create('opencli-page-state', {
+ type: 'basic',
+ title: 'OpenCLI',
+ message: 'Page state captured successfully',
+ iconUrl: 'icons/icon-48.png'
+ });
+ } else {
+ chrome.notifications.create('opencli-page-state-error', {
+ type: 'basic',
+ title: 'OpenCLI Error',
+ message: `Failed to capture page state: ${result.error}`,
+ iconUrl: 'icons/icon-48.png'
+ });
+ }
+ });
+ }
+});
+
+// ─── Get Page State Handler ─────────────────────────────────────────
+
+async function handleGetPageState(): Promise {
+ const workspace = 'browser:default';
+ try {
+ // 绑定到当前活跃标签页
+ const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+ const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+ const allTabs = await chrome.tabs.query({});
+ const boundTab = activeTabs.find((tab) => tab.id && (tab.url?.startsWith('http://') || tab.url?.startsWith('https://')))
+ ?? fallbackTabs.find((tab) => tab.id && (tab.url?.startsWith('http://') || tab.url?.startsWith('https://')))
+ ?? allTabs.find((tab) => tab.id && (tab.url?.startsWith('http://') || tab.url?.startsWith('https://')));
+
+ if (!boundTab?.id) {
+ return {
+ id: 'popup-state',
+ ok: false,
+ error: 'No active debuggable tab found',
+ };
+ }
+
+ // 设置工作区会话
+ setWorkspaceSession(workspace, {
+ windowId: boundTab.windowId,
+ owned: false,
+ preferredTabId: boundTab.id,
+ });
+ resetWindowIdleTimer(workspace);
+
+ // 生成快照脚本
+ const snapshotJs = generateSnapshotJs({
+ viewportExpand: 2000,
+ maxDepth: 50,
+ interactiveOnly: false,
+ maxTextLength: 120,
+ includeScrollInfo: true,
+ bboxDedup: true,
+ includeShadowDom: true,
+ includeIframes: true,
+ maxIframes: 5,
+ paintOrderCheck: true,
+ annotateRefs: true,
+ reportHidden: true,
+ filterAds: true,
+ markdownTables: true,
+ previousHashes: null,
+ });
+
+ // 执行快照脚本
+ const aggressive = workspace.startsWith('browser:') || workspace.startsWith('operate:');
+ const data = await executor.evaluateAsync(boundTab.id, snapshotJs, aggressive);
+
+ // 在页面上标记元素序号
+ const markElementsScript = `
+ (() => {
+ 'use strict';
+
+ // 移除之前的标记
+ document.querySelectorAll('.opencli-element-mark').forEach(el => el.remove());
+
+ // 遍历所有带有 data-opencli-ref 属性的元素
+ document.querySelectorAll('[data-opencli-ref]').forEach(el => {
+ try {
+ const rect = el.getBoundingClientRect();
+ const ref = el.getAttribute('data-opencli-ref');
+
+ if (rect.width > 0 && rect.height > 0 && ref) {
+ // 创建标记元素
+ const mark = document.createElement('div');
+ mark.className = 'opencli-element-mark';
+ mark.textContent = ref;
+ mark.style.position = 'absolute';
+ mark.style.left = '0';
+ mark.style.top = '0';
+ mark.style.transform = 'translate(-50%, -50%)';
+ mark.style.background = 'rgba(255, 0, 0, 0.8)';
+ mark.style.color = 'white';
+ mark.style.fontSize = '12px';
+ mark.style.fontWeight = 'bold';
+ mark.style.padding = '2px 6px';
+ mark.style.borderRadius = '10px';
+ mark.style.zIndex = '9999';
+ mark.style.pointerEvents = 'none';
+ mark.style.boxShadow = '0 2px 4px rgba(0, 0, 0, 0.3)';
+
+ // 计算中心位置
+ const centerX = rect.left + rect.width / 2;
+ const centerY = rect.top + rect.height / 2;
+
+ // 设置位置
+ mark.style.left = centerX + 'px';
+ mark.style.top = centerY + 'px';
+
+ // 添加到文档
+ document.body.appendChild(mark);
+ }
+ } catch (e) {
+ // 忽略错误
+ }
+ });
+ })()
+ `;
+
+ // 执行标记脚本
+ try {
+ await executor.evaluateAsync(boundTab.id, markElementsScript, aggressive);
+ } catch (err) {
+ // 忽略标记错误，不影响主功能
+ }
+
+ return {
+ id: 'popup-state',
+ ok: true,
+ data,
+ };
+ } catch (err) {
+ return {
+ id: 'popup-state',
+ ok: false,
+ error: err instanceof Error ? err.message : String(err),
+ };
+ }
+}
+
// ─── Command dispatcher ─────────────────────────────────────────────
async function handleCommand(cmd: Command): Promise {
diff --git a/extension/vite.config.ts b/extension/vite.config.ts
index f7cd0ecc1..618683865 100644
--- a/extension/vite.config.ts
+++ b/extension/vite.config.ts
@@ -15,4 +15,9 @@ export default defineConfig({
target: 'esnext',
minify: false,
},
+ resolve: {
+ alias: {
+ '@src': resolve(__dirname, '../src'),
+ },
+ },
});
diff --git a/package-lock.json b/package-lock.json
index f0db4a55d..5c62e09ef 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -196,6 +196,7 @@
"integrity": "sha512-y1IOpG6OSmTpGg/CT0YBb/EAhR2nsC18QWp9Jy8HO9iGySpcwaTvs5kHa17daP3BMTwWyaX9/1tDTDQshZzXdg==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"@algolia/client-common": "5.49.2",
"@algolia/requester-browser-xhr": "5.49.2",
@@ -404,31 +405,6 @@
}
}
},
- "node_modules/@emnapi/core": {
- "version": "1.9.2",
- "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.2.tgz",
- "integrity": "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA==",
- "dev": true,
- "license": "MIT",
- "optional": true,
- "peer": true,
- "dependencies": {
- "@emnapi/wasi-threads": "1.2.1",
- "tslib": "^2.4.0"
- }
- },
- "node_modules/@emnapi/runtime": {
- "version": "1.9.2",
- "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
- "integrity": "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==",
- "dev": true,
- "license": "MIT",
- "optional": true,
- "peer": true,
- "dependencies": {
- "tslib": "^2.4.0"
- }
- },
"node_modules/@emnapi/wasi-threads": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
@@ -436,7 +412,6 @@
"dev": true,
"license": "MIT",
"optional": true,
- "peer": true,
"dependencies": {
"tslib": "^2.4.0"
}
@@ -2168,6 +2143,7 @@
"integrity": "sha512-1K0wtDaRONwfhL4h8bbJ9qTjmY6rhGgRvvagXkMBsAOMNr+3Q2SffHECh9DIuNVrMA1JwA0zCwhyepgBZVakng==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"@algolia/abtesting": "1.15.2",
"@algolia/client-abtesting": "5.49.2",
@@ -2496,6 +2472,7 @@
"integrity": "sha512-/yNdlIkpWbM0ptxno3ONTuf+2g318kh2ez3KSeZN5dZ8YC6AAmgeWz+GasYYiBJPFaYcSAPeu4GfhUaChzIJXA==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"tabbable": "^6.4.0"
}
@@ -2624,6 +2601,7 @@
"integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
"dev": true,
"license": "MPL-2.0",
+ "peer": true,
"dependencies": {
"detect-libc": "^2.0.3"
},
@@ -3095,6 +3073,7 @@
"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
"dev": true,
"license": "MIT",
+ "peer": true,
"engines": {
"node": ">=12"
},
@@ -3483,6 +3462,7 @@
"integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"esbuild": "~0.27.0",
"get-tsconfig": "^4.7.5"
@@ -3512,6 +3492,7 @@
"integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
"dev": true,
"license": "Apache-2.0",
+ "peer": true,
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
@@ -3645,6 +3626,7 @@
"integrity": "sha512-nmu43Qvq9UopTRfMx2jOYW5l16pb3iDC1JH6yMuPkpVbzK0k+L7dfsEDH4jRgYFmsg0sTAqkojoZgzLMlwHsCQ==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"lightningcss": "^1.32.0",
"picomatch": "^4.0.4",
@@ -4209,6 +4191,7 @@
"integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"esbuild": "^0.21.3",
"postcss": "^8.4.43",
@@ -4351,6 +4334,7 @@
"integrity": "sha512-hTHLc6VNZyzzEH/l7PFGjpcTvUgiaPK5mdLkbjrTeWSRcEfxFrv56g/XckIYlE9ckuobsdwqd5mk2g1sBkMewg==",
"dev": true,
"license": "MIT",
+ "peer": true,
"dependencies": {
"@vue/compiler-dom": "3.5.30",
"@vue/compiler-sfc": "3.5.30",