opendevbrowser 0.0.11 → 0.0.15

package/extension/dist/logging.js

@@ -0,0 +1,50 @@
+const safeStringify = (value) => {
+    try {
+        const seen = new WeakSet();
+        return JSON.stringify(value, (_key, val) => {
+            if (typeof val !== "object" || val === null) {
+                return val;
+            }
+            if (seen.has(val)) {
+                return "[Circular]";
+            }
+            seen.add(val);
+            return val;
+        });
+    }
+    catch {
+        return "[Unserializable]";
+    }
+};
+const normalizeError = (error) => {
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+        };
+    }
+    if (error && typeof error === "object") {
+        const record = error;
+        const message = typeof record.message === "string" && record.message.trim()
+            ? record.message
+            : safeStringify(error);
+        const name = typeof record.name === "string" ? record.name : undefined;
+        const stack = typeof record.stack === "string" ? record.stack : undefined;
+        return { message, name, stack };
+    }
+    if (typeof error === "string") {
+        return { message: error };
+    }
+    return { message: String(error ?? "Unknown error") };
+};
+export const logError = (context, error, options) => {
+    const detail = normalizeError(error);
+    const payload = {
+        context,
+        code: options?.code ?? "unknown",
+        ...detail,
+        ...(options?.extra ?? {})
+    };
+    console.error("[opendevbrowser]", safeStringify(payload));
+};

package/extension/dist/ops/dom-bridge.js

@@ -0,0 +1,355 @@
+const DEFAULT_MAX_NODES = 1000;
+export class DomBridge {
+    async getOuterHtml(tabId, selector) {
+        const result = await runWithElement(tabId, selector, { type: "outerHTML" });
+        return result;
+    }
+    async getInnerText(tabId, selector) {
+        const result = await runWithElement(tabId, selector, { type: "innerText" });
+        return result;
+    }
+    async getAttr(tabId, selector, name) {
+        const result = await runWithElement(tabId, selector, { type: "getAttr", name });
+        return result;
+    }
+    async getValue(tabId, selector) {
+        const result = await runWithElement(tabId, selector, { type: "getValue" });
+        return result;
+    }
+    async isVisible(tabId, selector) {
+        const state = await this.getSelectorState(tabId, selector);
+        return state.visible;
+    }
+    async isEnabled(tabId, selector) {
+        const result = await runWithElement(tabId, selector, { type: "isEnabled" });
+        return Boolean(result);
+    }
+    async isChecked(tabId, selector) {
+        const result = await runWithElement(tabId, selector, { type: "isChecked" });
+        return Boolean(result);
+    }
+    async click(tabId, selector) {
+        await runWithElement(tabId, selector, { type: "click" });
+    }
+    async hover(tabId, selector) {
+        await runWithElement(tabId, selector, { type: "hover" });
+    }
+    async focus(tabId, selector) {
+        await runWithElement(tabId, selector, { type: "focus" });
+    }
+    async press(tabId, selector, key) {
+        const result = await runInTab(tabId, (sel, pressedKey) => {
+            const target = sel ? document.querySelector(sel) : document.activeElement;
+            if (!target) {
+                return { ok: false, error: "Element not found" };
+            }
+            if (target instanceof HTMLElement) {
+                target.focus();
+            }
+            const opts = { key: pressedKey, bubbles: true, cancelable: true };
+            target.dispatchEvent(new KeyboardEvent("keydown", opts));
+            target.dispatchEvent(new KeyboardEvent("keypress", opts));
+            target.dispatchEvent(new KeyboardEvent("keyup", opts));
+            return { ok: true };
+        }, [selector, key]);
+        assertRunResult(result);
+    }
+    async type(tabId, selector, text, clear, submit) {
+        await runWithElement(tabId, selector, { type: "type", value: text, clear, submit });
+    }
+    async setChecked(tabId, selector, checked) {
+        await runWithElement(tabId, selector, { type: "setChecked", checked });
+    }
+    async select(tabId, selector, values) {
+        await runWithElement(tabId, selector, { type: "select", values });
+    }
+    async scroll(tabId, dy, selector) {
+        const result = await runInTab(tabId, (sel, delta) => {
+            if (sel) {
+                const el = document.querySelector(sel);
+                if (!el) {
+                    return { ok: false, error: "Element not found" };
+                }
+                el.scrollBy(0, Number(delta));
+            }
+            else {
+                window.scrollBy(0, Number(delta));
+            }
+            return { ok: true };
+        }, [selector ?? null, dy]);
+        assertRunResult(result);
+    }
+    async scrollIntoView(tabId, selector) {
+        await runWithElement(tabId, selector, { type: "scrollIntoView" });
+    }
+    async getSelectorState(tabId, selector) {
+        const result = await runInTab(tabId, (sel) => {
+            const el = document.querySelector(sel);
+            if (!el) {
+                return { attached: false, visible: false };
+            }
+            const style = window.getComputedStyle(el);
+            const rect = el.getBoundingClientRect();
+            const visible = style.display !== "none"
+                && style.visibility !== "hidden"
+                && style.opacity !== "0"
+                && rect.width > 0
+                && rect.height > 0;
+            return { attached: true, visible };
+        }, [selector]);
+        return result;
+    }
+    async captureDom(tabId, selector, options = {}) {
+        const payload = await runInTab(tabId, (sel, opts) => {
+            const root = document.querySelector(sel);
+            if (!root) {
+                return { ok: false, error: "Element not found" };
+            }
+            const config = opts;
+            const shouldSanitize = config.sanitize !== false;
+            const maxNodes = typeof config.maxNodes === "number" ? config.maxNodes : 1000;
+            const inlineStyles = config.inlineStyles !== false;
+            const styleAllowlist = Array.isArray(config.styleAllowlist) ? config.styleAllowlist : [];
+            const skipStyleValues = Array.isArray(config.skipStyleValues) ? config.skipStyleValues : [];
+            const style = window.getComputedStyle(root);
+            const styles = {};
+            for (const prop of Array.from(style)) {
+                styles[prop] = style.getPropertyValue(prop);
+            }
+            const warnings = [];
+            const clone = root.cloneNode(true);
+            const originalElements = [root, ...Array.from(root.querySelectorAll("*"))];
+            const cloneElements = [clone, ...Array.from(clone.querySelectorAll("*"))];
+            const nodeLimit = Math.max(1, maxNodes);
+            if (originalElements.length > nodeLimit) {
+                const omitted = originalElements.length - nodeLimit;
+                warnings.push(`Export truncated at ${nodeLimit} nodes; ${omitted} nodes omitted.`);
+            }
+            const limit = Math.min(originalElements.length, nodeLimit);
+            if (inlineStyles) {
+                const skipSet = new Set(skipStyleValues);
+                for (let index = 0; index < limit; index += 1) {
+                    const source = originalElements[index];
+                    const target = cloneElements[index];
+                    if (!source || !target)
+                        continue;
+                    const computed = window.getComputedStyle(source);
+                    const parts = [];
+                    for (const prop of styleAllowlist) {
+                        const value = computed.getPropertyValue(prop).trim();
+                        if (value && !skipSet.has(value)) {
+                            parts.push(`${prop}: ${value};`);
+                        }
+                    }
+                    if (parts.length > 0) {
+                        target.setAttribute("style", parts.join(" "));
+                    }
+                }
+            }
+            if (originalElements.length > nodeLimit) {
+                for (let index = nodeLimit; index < cloneElements.length; index += 1) {
+                    const target = cloneElements[index];
+                    if (target) {
+                        target.remove();
+                    }
+                }
+            }
+            const container = document.createElement("template");
+            container.content.appendChild(clone);
+            if (shouldSanitize) {
+                const blockedTags = new Set([
+                    "script",
+                    "iframe",
+                    "object",
+                    "embed",
+                    "frame",
+                    "frameset",
+                    "applet",
+                    "base",
+                    "link",
+                    "meta",
+                    "noscript"
+                ]);
+                const urlAttrs = new Set(["href", "src", "action", "formaction", "xlink:href", "srcset"]);
+                const isDangerousUrl = (value) => {
+                    const normalized = value.trim().toLowerCase();
+                    return normalized.startsWith("javascript:")
+                        || normalized.startsWith("data:")
+                        || normalized.startsWith("vbscript:");
+                };
+                const isDangerousSrcset = (value) => {
+                    const entries = value.split(",");
+                    return entries.some((entry) => {
+                        const url = entry.trim().split(/\s+/)[0] || "";
+                        return isDangerousUrl(url);
+                    });
+                };
+                const DANGEROUS_CSS_PATTERNS = [
+                    /url\s*\(/i,
+                    /expression\s*\(/i,
+                    /-moz-binding/i,
+                    /behavior\s*:/i,
+                    /javascript\s*:/i
+                ];
+                for (const el of Array.from(container.content.querySelectorAll("*"))) {
+                    if (blockedTags.has(el.tagName.toLowerCase())) {
+                        el.remove();
+                        continue;
+                    }
+                    for (const attr of Array.from(el.attributes)) {
+                        const name = attr.name.toLowerCase();
+                        const value = attr.value;
+                        if (name.startsWith("on")) {
+                            el.removeAttribute(attr.name);
+                            continue;
+                        }
+                        if (urlAttrs.has(name)) {
+                            if ((name === "srcset" && isDangerousSrcset(value)) || isDangerousUrl(value)) {
+                                el.removeAttribute(attr.name);
+                            }
+                            continue;
+                        }
+                        if (name === "style") {
+                            const normalized = value.toLowerCase();
+                            if (DANGEROUS_CSS_PATTERNS.some((pattern) => pattern.test(normalized))) {
+                                el.removeAttribute(attr.name);
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                ok: true,
+                value: {
+                    html: container.innerHTML,
+                    styles,
+                    warnings,
+                    inlineStyles
+                }
+            };
+        }, [selector, {
+                sanitize: options.sanitize !== false,
+                maxNodes: options.maxNodes ?? DEFAULT_MAX_NODES,
+                inlineStyles: options.inlineStyles !== false,
+                styleAllowlist: options.styleAllowlist ?? [],
+                skipStyleValues: options.skipStyleValues ?? []
+            }]);
+        if (!payload || typeof payload !== "object" || payload.ok !== true) {
+            const record = payload;
+            throw new Error(record?.error || "Dom capture failed");
+        }
+        return payload.value;
+    }
+}
+const runWithElement = async (tabId, selector, action) => {
+    const result = await runInTab(tabId, (sel, act) => {
+        const el = document.querySelector(sel);
+        if (!el) {
+            return { ok: false, error: "Element not found" };
+        }
+        const action = act;
+        switch (action.type) {
+            case "outerHTML":
+                return { ok: true, value: el.outerHTML };
+            case "innerText":
+                return { ok: true, value: el.innerText || el.textContent || "" };
+            case "getAttr":
+                return { ok: true, value: el.getAttribute(action.name) };
+            case "getValue":
+                if ("value" in el) {
+                    return { ok: true, value: String(el.value ?? "") };
+                }
+                return { ok: true, value: null };
+            case "isEnabled":
+                if ("disabled" in el) {
+                    return { ok: true, value: !el.disabled };
+                }
+                return { ok: true, value: true };
+            case "isChecked":
+                if ("checked" in el) {
+                    return { ok: true, value: Boolean(el.checked) };
+                }
+                return { ok: true, value: false };
+            case "click":
+                el.click();
+                return { ok: true, value: true };
+            case "hover": {
+                const event = new MouseEvent("mouseover", { bubbles: true, cancelable: true, view: window });
+                el.dispatchEvent(event);
+                return { ok: true, value: true };
+            }
+            case "focus":
+                el.focus();
+                return { ok: true, value: true };
+            case "type": {
+                const input = el;
+                if (action.clear) {
+                    input.value = "";
+                }
+                input.value = String(action.value ?? "");
+                input.dispatchEvent(new Event("input", { bubbles: true }));
+                input.dispatchEvent(new Event("change", { bubbles: true }));
+                if (action.submit) {
+                    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+                }
+                return { ok: true, value: true };
+            }
+            case "setChecked":
+                if (!("checked" in el)) {
+                    return { ok: false, error: "Element does not support checked" };
+                }
+                el.checked = Boolean(action.checked);
+                el.dispatchEvent(new Event("change", { bubbles: true }));
+                return { ok: true, value: true };
+            case "select":
+                if (!(el instanceof HTMLSelectElement)) {
+                    return { ok: false, error: "Element is not a select" };
+                }
+                for (const option of Array.from(el.options)) {
+                    option.selected = action.values.includes(option.value);
+                }
+                el.dispatchEvent(new Event("change", { bubbles: true }));
+                return { ok: true, value: true };
+            case "scrollIntoView":
+                el.scrollIntoView({ block: "center", inline: "nearest" });
+                return { ok: true, value: true };
+            default:
+                return { ok: false, error: "Unknown action" };
+        }
+    }, [selector, action]);
+    if (!result || typeof result !== "object") {
+        throw new Error("Script execution failed");
+    }
+    const record = result;
+    if (record.ok !== true) {
+        throw new Error(record.error || "Script execution failed");
+    }
+    return record.value;
+};
+const runInTab = async (tabId, func, args = []) => {
+    try {
+        const results = await chrome.scripting.executeScript({
+            target: { tabId },
+            func,
+            args
+        });
+        const [result] = results;
+        if (!result) {
+            throw new Error("No script result");
+        }
+        return result.result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Script execution failed";
+        throw new Error(message);
+    }
+};
+const assertRunResult = (value) => {
+    if (!value || typeof value !== "object") {
+        throw new Error("Script execution failed");
+    }
+    const record = value;
+    if (record.ok === false) {
+        throw new Error(record.error || "Script execution failed");
+    }
+};