opendevbrowser 0.0.12 → 0.0.16

package/extension/dist/ops/ops-session-store.js

@@ -0,0 +1,203 @@
+import { DEFAULT_OPS_PARALLELISM_POLICY, createOpsGovernorState } from "./parallelism-governor.js";
+export class OpsRefStore {
+    refsByTarget = new Map();
+    snapshotByTarget = new Map();
+    setSnapshot(targetId, entries) {
+        const map = new Map();
+        for (const entry of entries) {
+            map.set(entry.ref, entry);
+        }
+        const snapshotId = createId();
+        this.refsByTarget.set(targetId, map);
+        this.snapshotByTarget.set(targetId, snapshotId);
+        return { snapshotId, targetId, count: entries.length };
+    }
+    resolve(targetId, ref) {
+        const map = this.refsByTarget.get(targetId);
+        if (!map)
+            return null;
+        return map.get(ref) ?? null;
+    }
+    getSnapshotId(targetId) {
+        return this.snapshotByTarget.get(targetId) ?? null;
+    }
+    getRefCount(targetId) {
+        const map = this.refsByTarget.get(targetId);
+        return map ? map.size : 0;
+    }
+    clearTarget(targetId) {
+        this.refsByTarget.delete(targetId);
+        this.snapshotByTarget.delete(targetId);
+    }
+}
+export class OpsSessionStore {
+    sessions = new Map();
+    tabToSession = new Map();
+    createSession(ownerClientId, tabId, leaseId, info, options) {
+        const id = createId();
+        const targetId = `tab-${tabId}`;
+        const parallelismPolicy = options?.parallelismPolicy ?? DEFAULT_OPS_PARALLELISM_POLICY;
+        const target = {
+            targetId,
+            tabId,
+            url: info?.url,
+            title: info?.title
+        };
+        const session = {
+            id,
+            ownerClientId,
+            leaseId,
+            state: "active",
+            tabId,
+            targetId,
+            activeTargetId: targetId,
+            createdAt: Date.now(),
+            lastUsedAt: Date.now(),
+            targets: new Map([[targetId, target]]),
+            nameToTarget: new Map(),
+            targetToName: new Map(),
+            refStore: new OpsRefStore(),
+            consoleEvents: [],
+            networkEvents: [],
+            networkRequests: new Map(),
+            consoleSeq: 0,
+            networkSeq: 0,
+            queue: Promise.resolve(),
+            targetQueues: new Map(),
+            targetQueueDepth: new Map(),
+            targetQueueOldestAt: new Map(),
+            parallelInFlight: 0,
+            pendingParallel: 0,
+            discardedSignals: 0,
+            frozenSignals: 0,
+            parallelismPolicy,
+            parallelismState: createOpsGovernorState(parallelismPolicy, "extensionOpsHeaded")
+        };
+        this.sessions.set(id, session);
+        this.tabToSession.set(tabId, id);
+        return session;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+    }
+    getByTabId(tabId) {
+        const id = this.tabToSession.get(tabId);
+        if (!id)
+            return null;
+        return this.sessions.get(id) ?? null;
+    }
+    listOwnedBy(clientId) {
+        return Array.from(this.sessions.values()).filter((session) => session.ownerClientId === clientId);
+    }
+    delete(sessionId) {
+        const session = this.sessions.get(sessionId) ?? null;
+        if (!session)
+            return null;
+        this.sessions.delete(sessionId);
+        for (const target of session.targets.values()) {
+            this.tabToSession.delete(target.tabId);
+        }
+        return session;
+    }
+    addTarget(sessionId, tabId, info) {
+        const session = this.requireSession(sessionId);
+        const targetId = `tab-${tabId}`;
+        const target = {
+            targetId,
+            tabId,
+            url: info?.url,
+            title: info?.title
+        };
+        session.targets.set(targetId, target);
+        this.tabToSession.set(tabId, sessionId);
+        if (!session.activeTargetId) {
+            session.activeTargetId = targetId;
+        }
+        return target;
+    }
+    removeTarget(sessionId, targetId) {
+        const session = this.requireSession(sessionId);
+        const target = session.targets.get(targetId) ?? null;
+        if (!target)
+            return null;
+        session.targets.delete(targetId);
+        this.tabToSession.delete(target.tabId);
+        const name = session.targetToName.get(targetId);
+        if (name) {
+            session.targetToName.delete(targetId);
+            session.nameToTarget.delete(name);
+        }
+        if (session.activeTargetId === targetId) {
+            const [first] = session.targets.keys();
+            session.activeTargetId = first ?? "";
+        }
+        session.targetQueues.delete(targetId);
+        session.targetQueueDepth.delete(targetId);
+        session.targetQueueOldestAt.delete(targetId);
+        session.refStore.clearTarget(targetId);
+        return target;
+    }
+    getTargetIdByTabId(sessionId, tabId) {
+        const session = this.requireSession(sessionId);
+        for (const target of session.targets.values()) {
+            if (target.tabId === tabId) {
+                return target.targetId;
+            }
+        }
+        return null;
+    }
+    removeTargetByTabId(sessionId, tabId) {
+        const targetId = this.getTargetIdByTabId(sessionId, tabId);
+        if (!targetId)
+            return null;
+        return this.removeTarget(sessionId, targetId);
+    }
+    setActiveTarget(sessionId, targetId) {
+        const session = this.requireSession(sessionId);
+        if (!session.targets.has(targetId)) {
+            throw new Error(`Unknown targetId: ${targetId}`);
+        }
+        session.activeTargetId = targetId;
+    }
+    setName(sessionId, targetId, name) {
+        const session = this.requireSession(sessionId);
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new Error("Name must be non-empty");
+        }
+        if (!session.targets.has(targetId)) {
+            throw new Error(`Unknown targetId: ${targetId}`);
+        }
+        const existing = session.nameToTarget.get(trimmed);
+        if (existing && existing !== targetId) {
+            throw new Error(`Name already in use: ${trimmed}`);
+        }
+        const previousName = session.targetToName.get(targetId);
+        if (previousName && previousName !== trimmed) {
+            session.nameToTarget.delete(previousName);
+        }
+        session.nameToTarget.set(trimmed, targetId);
+        session.targetToName.set(targetId, trimmed);
+    }
+    getTargetIdByName(sessionId, name) {
+        const session = this.requireSession(sessionId);
+        return session.nameToTarget.get(name.trim()) ?? null;
+    }
+    listNamedTargets(sessionId) {
+        const session = this.requireSession(sessionId);
+        return Array.from(session.nameToTarget.entries()).map(([name, targetId]) => ({ name, targetId }));
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Unknown sessionId: ${sessionId}`);
+        }
+        return session;
+    }
+}
+const createId = () => {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};

package/extension/dist/ops/parallelism-governor.js

@@ -0,0 +1,117 @@
+export const DEFAULT_OPS_PARALLELISM_POLICY = {
+    floor: 1,
+    backpressureTimeoutMs: 5000,
+    sampleIntervalMs: 2000,
+    recoveryStableWindows: 3,
+    hostFreeMemMediumPct: 25,
+    hostFreeMemHighPct: 18,
+    hostFreeMemCriticalPct: 10,
+    rssBudgetMb: 2048,
+    rssSoftPct: 65,
+    rssHighPct: 75,
+    rssCriticalPct: 85,
+    queueAgeHighMs: 2000,
+    queueAgeCriticalMs: 5000,
+    modeCaps: {
+        managedHeaded: 6,
+        managedHeadless: 8,
+        cdpConnectHeaded: 6,
+        cdpConnectHeadless: 8,
+        extensionOpsHeaded: 6,
+        extensionLegacyCdpHeaded: 1
+    }
+};
+const clamp = (value, floor, ceil) => {
+    if (value < floor)
+        return floor;
+    if (value > ceil)
+        return ceil;
+    return value;
+};
+const floorPercent = (value) => clamp(Number.isFinite(value) ? value : 0, 0, 100);
+const classifyPressure = (policy, input) => {
+    const hostFreeMemPct = floorPercent(input.hostFreeMemPct);
+    const rssUsagePct = floorPercent(input.rssUsagePct);
+    const queueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const discardedSignals = Math.max(0, input.discardedSignals ?? 0);
+    const frozenSignals = Math.max(0, input.frozenSignals ?? 0);
+    const critical = hostFreeMemPct <= policy.hostFreeMemCriticalPct
+        || rssUsagePct >= policy.rssCriticalPct
+        || queueAgeMs >= policy.queueAgeCriticalMs;
+    if (critical)
+        return "critical";
+    const high = hostFreeMemPct <= policy.hostFreeMemHighPct
+        || rssUsagePct >= policy.rssHighPct
+        || queueAgeMs >= policy.queueAgeHighMs
+        || discardedSignals > 0;
+    if (high)
+        return "high";
+    const medium = hostFreeMemPct <= policy.hostFreeMemMediumPct
+        || rssUsagePct >= policy.rssSoftPct
+        || frozenSignals > 0;
+    return medium ? "medium" : "healthy";
+};
+const pressurePenalty = (pressure) => {
+    switch (pressure) {
+        case "medium":
+            return 1;
+        case "high":
+            return 2;
+        case "critical":
+            return Number.MAX_SAFE_INTEGER;
+        default:
+            return 0;
+    }
+};
+export const resolveOpsStaticCap = (policy, modeVariant) => {
+    const cap = policy.modeCaps[modeVariant];
+    return clamp(cap, policy.floor, cap);
+};
+export const createOpsGovernorState = (policy, modeVariant) => {
+    const staticCap = resolveOpsStaticCap(policy, modeVariant);
+    return {
+        modeVariant,
+        staticCap,
+        effectiveCap: staticCap,
+        healthyWindows: 0,
+        lastSampleAt: 0,
+        lastPressure: "healthy"
+    };
+};
+export const evaluateOpsGovernor = (policy, current, input, sampledAt = Date.now()) => {
+    const normalizedQueueDepth = Math.max(0, Number.isFinite(input.queueDepth) ? input.queueDepth : 0);
+    const normalizedQueueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const pressure = classifyPressure(policy, input);
+    const basePenalty = pressurePenalty(pressure);
+    const lifecyclePenalty = Math.max(0, input.discardedSignals ?? 0) + Math.max(0, input.frozenSignals ?? 0);
+    const targetCap = pressure === "critical"
+        ? policy.floor
+        : clamp(current.staticCap - basePenalty - lifecyclePenalty, policy.floor, current.staticCap);
+    let effectiveCap = current.effectiveCap;
+    let healthyWindows = pressure === "healthy" ? current.healthyWindows + 1 : 0;
+    if (targetCap < current.effectiveCap) {
+        effectiveCap = targetCap;
+        healthyWindows = 0;
+    }
+    else if (targetCap > current.effectiveCap) {
+        const windowsRequired = Math.max(1, policy.recoveryStableWindows);
+        if (healthyWindows >= windowsRequired) {
+            effectiveCap = clamp(current.effectiveCap + 1, policy.floor, targetCap);
+            healthyWindows = 0;
+        }
+    }
+    return {
+        state: {
+            modeVariant: current.modeVariant,
+            staticCap: current.staticCap,
+            effectiveCap,
+            healthyWindows,
+            lastSampleAt: sampledAt,
+            lastPressure: pressure
+        },
+        pressure,
+        targetCap,
+        waitQueueDepth: normalizedQueueDepth,
+        waitQueueAgeMs: normalizedQueueAgeMs
+    };
+};

package/extension/dist/ops/redaction.js

@@ -0,0 +1,52 @@
+const JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+const TOKEN_LIKE_PATTERN = /\b[A-Za-z0-9_-]{16,}\b/g;
+const API_KEY_PREFIX_PATTERN = /\b(sk_|pk_|api_|key_|token_|secret_|bearer_)[A-Za-z0-9_-]+\b/gi;
+const SENSITIVE_KV_PATTERN = /\b(token|key|secret|password|auth|bearer|credential)[=:]\s*\S+/gi;
+const shouldRedactToken = (token) => {
+    if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(token)) {
+        return true;
+    }
+    const categories = [
+        /[a-z]/.test(token),
+        /[A-Z]/.test(token),
+        /\d/.test(token),
+        /[_-]/.test(token)
+    ].filter(Boolean).length;
+    return categories >= 2;
+};
+export const redactConsoleText = (text) => {
+    let result = text.replace(SENSITIVE_KV_PATTERN, (match) => {
+        const sepIndex = match.search(/[=:]/);
+        return match.slice(0, sepIndex + 1) + "[REDACTED]";
+    });
+    result = result.replace(JWT_PATTERN, "[REDACTED]");
+    result = result.replace(API_KEY_PREFIX_PATTERN, "[REDACTED]");
+    result = result.replace(TOKEN_LIKE_PATTERN, (match) => (shouldRedactToken(match) ? "[REDACTED]" : match));
+    return result;
+};
+const shouldRedactPathSegment = (segment) => {
+    if (segment.length < 16)
+        return false;
+    if (/^\d+$/.test(segment))
+        return false;
+    if (/^[a-f0-9-]{36}$/i.test(segment))
+        return false;
+    if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(segment))
+        return true;
+    const categories = [/[a-z]/, /[A-Z]/, /\d/, /[_-]/].filter(r => r.test(segment)).length;
+    return categories >= 3 && segment.length >= 20;
+};
+export const redactUrl = (rawUrl) => {
+    try {
+        const parsed = new URL(rawUrl);
+        parsed.search = "";
+        parsed.hash = "";
+        const segments = parsed.pathname.split("/");
+        const redactedSegments = segments.map(segment => shouldRedactPathSegment(segment) ? "[REDACTED]" : segment);
+        parsed.pathname = redactedSegments.join("/");
+        return parsed.toString();
+    }
+    catch {
+        return rawUrl.split(/[?#]/)[0] || rawUrl;
+    }
+};

package/extension/dist/ops/snapshot-builder.js

@@ -0,0 +1,4 @@
+import { buildSnapshotFromCdp } from "./snapshot-shared.js";
+export async function buildSnapshot(send, mode, mainFrameOnly = true, maxNodes) {
+    return await buildSnapshotFromCdp(send, mode, mainFrameOnly, maxNodes);
+}

package/extension/dist/ops/snapshot-shared.js

@@ -0,0 +1,236 @@
+const DEFAULT_MAX_AX_NODES = 1000;
+const ACTIONABLE_ROLES = new Set([
+    "button",
+    "link",
+    "textbox",
+    "searchbox",
+    "textarea",
+    "checkbox",
+    "radio",
+    "combobox",
+    "listbox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "switch",
+    "tab",
+    "slider",
+    "spinbutton",
+    "treeitem"
+]);
+const SEMANTIC_ROLES = new Set([
+    "heading",
+    "article",
+    "main",
+    "navigation",
+    "region",
+    "section",
+    "form",
+    "list",
+    "listitem",
+    "paragraph",
+    "img",
+    "table",
+    "row",
+    "cell",
+    "columnheader",
+    "rowheader",
+    "banner",
+    "contentinfo",
+    "complementary"
+]);
+export const selectorFunction = function () {
+    if (!(this instanceof Element))
+        return null;
+    const escape = (value) => {
+        if (typeof CSS !== "undefined" && CSS.escape) {
+            return CSS.escape(value);
+        }
+        return String(value).replace(/([^\w-])/g, "\\$1");
+    };
+    const isUniqueSelector = (selector) => {
+        try {
+            return document.querySelectorAll(selector).length === 1;
+        }
+        catch {
+            return false;
+        }
+    };
+    const testId = this.getAttribute("data-testid");
+    if (testId) {
+        const selector = '[data-testid="' + escape(testId) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
+    }
+    const ariaLabel = this.getAttribute("aria-label");
+    if (ariaLabel && ariaLabel.length < 50) {
+        const selector = '[aria-label="' + escape(ariaLabel) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
+    }
+    const buildPathSelector = (start) => {
+        const parts = [];
+        let current = start;
+        while (current && current.nodeType === Node.ELEMENT_NODE) {
+            let selector = current.nodeName.toLowerCase();
+            if (current.id) {
+                const withId = selector + "#" + escape(current.id);
+                if (isUniqueSelector(withId)) {
+                    parts.unshift(withId);
+                    break;
+                }
+            }
+            const parentEl = current.parentElement;
+            if (!parentEl) {
+                parts.unshift(selector);
+                break;
+            }
+            let index = 1;
+            let sibling = current;
+            while (sibling && sibling.previousElementSibling) {
+                sibling = sibling.previousElementSibling;
+                index += 1;
+            }
+            selector += ":nth-child(" + index + ")";
+            parts.unshift(selector);
+            current = parentEl;
+        }
+        return parts.join(" > ");
+    };
+    return buildPathSelector(this);
+};
+const SELECTOR_FUNCTION = selectorFunction.toString();
+export async function buildSnapshotFromCdp(send, mode, mainFrameOnly = true, maxNodes) {
+    await send("Accessibility.enable", {});
+    await send("DOM.enable", {});
+    const result = await send("Accessibility.getFullAXTree", {});
+    const nodes = Array.isArray(result.nodes) ? result.nodes : [];
+    const entries = [];
+    const lines = [];
+    const warnings = [];
+    const maxEntries = typeof maxNodes === "number" ? maxNodes : DEFAULT_MAX_AX_NODES;
+    let skippedFrameCount = 0;
+    for (const node of nodes) {
+        if (entries.length >= maxEntries)
+            break;
+        if (node.ignored)
+            continue;
+        if (typeof node.backendDOMNodeId !== "number")
+            continue;
+        if (mainFrameOnly && node.frameId) {
+            skippedFrameCount += 1;
+            continue;
+        }
+        const role = extractValue(node.role) || extractValue(node.chromeRole);
+        if (!role)
+            continue;
+        if (!shouldInclude(role, mode))
+            continue;
+        const selector = await resolveSelector(send, node.backendDOMNodeId);
+        if (!selector)
+            continue;
+        const ref = `r${entries.length + 1}`;
+        const name = redactText(extractValue(node.name));
+        const value = redactText(extractValue(node.value));
+        const disabled = isTruthyProperty(node.properties, "disabled");
+        const checked = isTruthyProperty(node.properties, "checked");
+        entries.push({
+            ref,
+            selector,
+            backendNodeId: node.backendDOMNodeId,
+            frameId: node.frameId,
+            role,
+            name
+        });
+        lines.push(formatNode({
+            ref,
+            role,
+            name,
+            value,
+            disabled,
+            checked
+        }));
+    }
+    if (mainFrameOnly && skippedFrameCount > 0) {
+        warnings.push(`Skipped ${skippedFrameCount} iframe nodes; snapshot limited to main frame.`);
+    }
+    return { entries, lines, warnings };
+}
+async function resolveSelector(send, backendNodeId) {
+    const resolved = await send("DOM.resolveNode", { backendNodeId });
+    const objectId = resolved.object?.objectId;
+    if (!objectId)
+        return null;
+    const result = await send("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: SELECTOR_FUNCTION,
+        returnByValue: true
+    });
+    const selector = result.result?.value;
+    if (typeof selector !== "string" || selector.trim().length === 0) {
+        return null;
+    }
+    return selector;
+}
+function shouldInclude(role, mode) {
+    const normalized = role.toLowerCase();
+    if (ACTIONABLE_ROLES.has(normalized))
+        return true;
+    if (mode === "actionables")
+        return false;
+    return SEMANTIC_ROLES.has(normalized);
+}
+function formatNode(node) {
+    const name = redactText(node.name || "");
+    const value = redactText(node.value || "");
+    const parts = [];
+    parts.push(`[${node.ref}]`);
+    parts.push(node.role);
+    if (node.disabled) {
+        parts.push("disabled");
+    }
+    if (node.checked) {
+        parts.push("checked");
+    }
+    if (name) {
+        parts.push(`\"${name}\"`);
+    }
+    if (value) {
+        parts.push(`value=\"${value}\"`);
+    }
+    return parts.join(" ");
+}
+function redactText(text) {
+    const trimmed = (text ?? "").trim();
+    if (!trimmed)
+        return "";
+    return trimmed.replace(/[A-Za-z0-9+/_-]{24,}/g, "[redacted]");
+}
+function extractValue(value) {
+    if (!value || typeof value.value === "undefined" || value.value === null)
+        return "";
+    if (typeof value.value === "string")
+        return value.value;
+    if (typeof value.value === "number" || typeof value.value === "boolean") {
+        return String(value.value);
+    }
+    return "";
+}
+function isTruthyProperty(properties, name) {
+    if (!properties)
+        return false;
+    const found = properties.find((prop) => prop.name === name);
+    if (!found || !found.value)
+        return false;
+    const value = found.value.value;
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string")
+        return value.toLowerCase() === "true";
+    if (typeof value === "number")
+        return value !== 0;
+    return false;
+}