opendevbrowser 0.0.16 → 0.0.18

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

@@ -1,13 +1,23 @@
 import { DEFAULT_OPS_PARALLELISM_POLICY, createOpsGovernorState } from "./parallelism-governor.js";
+import { createCoordinatorId, TargetSessionCoordinator } from "./target-session-coordinator.js";
 export class OpsRefStore {
     refsByTarget = new Map();
     snapshotByTarget = new Map();
+    refCounterByTarget = new Map();
+    nextRef(targetId) {
+        const next = (this.refCounterByTarget.get(targetId) ?? 0) + 1;
+        this.refCounterByTarget.set(targetId, next);
+        return `r${next}`;
+    }
     setSnapshot(targetId, entries) {
         const map = new Map();
+        const snapshotId = createCoordinatorId();
         for (const entry of entries) {
-            map.set(entry.ref, entry);
+            map.set(entry.ref, {
+                ...entry,
+                snapshotId
+            });
         }
-        const snapshotId = createId();
         this.refsByTarget.set(targetId, map);
         this.snapshotByTarget.set(targetId, snapshotId);
         return { snapshotId, targetId, count: entries.length };
@@ -31,32 +41,14 @@ export class OpsRefStore {
     }
 }
 export class OpsSessionStore {
-    sessions = new Map();
-    tabToSession = new Map();
-    createSession(ownerClientId, tabId, leaseId, info, options) {
-        const id = createId();
-        const targetId = `tab-${tabId}`;
+    coordinator = new TargetSessionCoordinator();
+    createSession(ownerClientId, tabId, leaseId, info, options, sessionId) {
         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(),
+        return this.coordinator.createSession(ownerClientId, tabId, leaseId, info, {
             refStore: new OpsRefStore(),
+            syntheticTargets: new Map(),
+            dialogs: new Map(),
+            fileChoosers: new Map(),
             consoleEvents: [],
             networkEvents: [],
             networkRequests: new Map(),
@@ -72,132 +64,125 @@ export class OpsSessionStore {
             frozenSignals: 0,
             parallelismPolicy,
             parallelismState: createOpsGovernorState(parallelismPolicy, "extensionOpsHeaded")
-        };
-        this.sessions.set(id, session);
-        this.tabToSession.set(tabId, id);
-        return session;
+        }, sessionId);
     }
     get(sessionId) {
-        return this.sessions.get(sessionId) ?? null;
+        return this.coordinator.get(sessionId);
     }
     getByTabId(tabId) {
-        const id = this.tabToSession.get(tabId);
-        if (!id)
-            return null;
-        return this.sessions.get(id) ?? null;
+        return this.coordinator.getByTabId(tabId);
     }
     listOwnedBy(clientId) {
-        return Array.from(this.sessions.values()).filter((session) => session.ownerClientId === clientId);
+        return this.coordinator.listOwnedBy(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;
+        return this.coordinator.delete(sessionId);
     }
     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;
+        return this.coordinator.addTarget(sessionId, tabId, info);
     }
     removeTarget(sessionId, targetId) {
         const session = this.requireSession(sessionId);
-        const target = session.targets.get(targetId) ?? null;
+        const target = this.coordinator.removeTarget(sessionId, targetId);
         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);
+        session.syntheticTargets.delete(targetId);
+        session.dialogs.delete(targetId);
+        session.fileChoosers.delete(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;
+        return this.coordinator.getTargetIdByTabId(sessionId, tabId);
     }
     removeTargetByTabId(sessionId, tabId) {
-        const targetId = this.getTargetIdByTabId(sessionId, tabId);
+        const targetId = this.coordinator.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;
+        this.coordinator.setActiveTarget(sessionId, targetId);
     }
     setName(sessionId, targetId, name) {
+        this.coordinator.setName(sessionId, targetId, name);
+    }
+    getTargetIdByName(sessionId, name) {
+        return this.coordinator.getTargetIdByName(sessionId, name);
+    }
+    listNamedTargets(sessionId) {
+        return this.coordinator.listNamedTargets(sessionId);
+    }
+    upsertSyntheticTarget(sessionId, target) {
         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.syntheticTargets.get(target.targetId);
+        const nextTarget = {
+            ...(existing ?? {}),
+            ...target,
+            tabId: target.tabId,
+            type: target.type,
+            attachedAt: target.attachedAt
+        };
+        session.syntheticTargets.set(target.targetId, nextTarget);
+        return nextTarget;
+    }
+    getSyntheticTarget(sessionId, targetId) {
+        return this.requireSession(sessionId).syntheticTargets.get(targetId) ?? null;
+    }
+    listSyntheticTargets(sessionId) {
+        return Array.from(this.requireSession(sessionId).syntheticTargets.values());
+    }
+    findSyntheticTargetBySessionId(sessionId, childSessionId) {
+        const session = this.requireSession(sessionId);
+        for (const target of session.syntheticTargets.values()) {
+            if (target.sessionId === childSessionId) {
+                return target;
+            }
         }
-        const existing = session.nameToTarget.get(trimmed);
-        if (existing && existing !== targetId) {
-            throw new Error(`Name already in use: ${trimmed}`);
+        return null;
+    }
+    removeSyntheticTarget(sessionId, targetId) {
+        const session = this.requireSession(sessionId);
+        const existing = session.syntheticTargets.get(targetId) ?? null;
+        if (!existing) {
+            return null;
         }
-        const previousName = session.targetToName.get(targetId);
-        if (previousName && previousName !== trimmed) {
-            session.nameToTarget.delete(previousName);
+        if (session.activeTargetId === targetId) {
+            session.activeTargetId = null;
         }
-        session.nameToTarget.set(trimmed, targetId);
-        session.targetToName.set(targetId, trimmed);
+        session.syntheticTargets.delete(targetId);
+        session.refStore.clearTarget(targetId);
+        session.dialogs.delete(targetId);
+        session.fileChoosers.delete(targetId);
+        return existing;
     }
-    getTargetIdByName(sessionId, name) {
+    getDialog(sessionId, targetId) {
+        return this.requireSession(sessionId).dialogs.get(targetId) ?? null;
+    }
+    setDialog(sessionId, targetId, dialog) {
         const session = this.requireSession(sessionId);
-        return session.nameToTarget.get(name.trim()) ?? null;
+        session.dialogs.set(targetId, dialog);
+        return dialog;
     }
-    listNamedTargets(sessionId) {
+    clearDialog(sessionId, targetId) {
+        this.requireSession(sessionId).dialogs.delete(targetId);
+    }
+    getFileChooser(sessionId, targetId) {
+        return this.requireSession(sessionId).fileChoosers.get(targetId) ?? null;
+    }
+    setFileChooser(sessionId, targetId, chooser) {
         const session = this.requireSession(sessionId);
-        return Array.from(session.nameToTarget.entries()).map(([name, targetId]) => ({ name, targetId }));
+        session.fileChoosers.set(targetId, chooser);
+        return chooser;
+    }
+    clearFileChooser(sessionId, targetId) {
+        this.requireSession(sessionId).fileChoosers.delete(targetId);
     }
     requireSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Unknown sessionId: ${sessionId}`);
-        }
-        return session;
+        return this.coordinator.requireSession(sessionId);
     }
 }
-const createId = () => {
-    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
-        return crypto.randomUUID();
-    }
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-};
+export const createOpsSessionId = () => createCoordinatorId();

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

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

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

@@ -103,7 +103,7 @@ export const selectorFunction = function () {
     return buildPathSelector(this);
 };
 const SELECTOR_FUNCTION = selectorFunction.toString();
-export async function buildSnapshotFromCdp(send, mode, mainFrameOnly = true, maxNodes) {
+export async function buildSnapshotFromCdp(send, mode, createRef, mainFrameOnly = true, maxNodes) {
     await send("Accessibility.enable", {});
     await send("DOM.enable", {});
     const result = await send("Accessibility.getFullAXTree", {});
@@ -132,7 +132,7 @@ export async function buildSnapshotFromCdp(send, mode, mainFrameOnly = true, max
         const selector = await resolveSelector(send, node.backendDOMNodeId);
         if (!selector)
             continue;
-        const ref = `r${entries.length + 1}`;
+        const ref = createRef();
         const name = redactText(extractValue(node.name));
         const value = redactText(extractValue(node.value));
         const disabled = isTruthyProperty(node.properties, "disabled");

package/extension/dist/ops/target-session-coordinator.js

@@ -0,0 +1,159 @@
+export class TargetSessionCoordinator {
+    sessions = new Map();
+    tabToSession = new Map();
+    createSession(ownerClientId, tabId, leaseId, info, extra, sessionId) {
+        const id = sessionId ?? createCoordinatorId();
+        const targetId = `tab-${tabId}`;
+        const target = {
+            targetId,
+            tabId,
+            url: info?.url,
+            title: info?.title,
+            openerTargetId: undefined
+        };
+        const createdAt = Date.now();
+        const session = {
+            id,
+            ownerClientId,
+            leaseId,
+            state: "active",
+            tabId,
+            targetId,
+            activeTargetId: targetId,
+            createdAt,
+            lastUsedAt: createdAt,
+            targets: new Map([[targetId, target]]),
+            nameToTarget: new Map(),
+            targetToName: new Map(),
+            ...extra
+        };
+        this.sessions.set(id, session);
+        this.tabToSession.set(tabId, id);
+        return session;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+    }
+    getByTabId(tabId) {
+        const sessionId = this.tabToSession.get(tabId);
+        if (!sessionId) {
+            return null;
+        }
+        return this.sessions.get(sessionId) ?? 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,
+            openerTargetId: info?.openerTargetId
+        };
+        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 ?? null;
+        }
+        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}`);
+        }
+        session.lastUsedAt = Date.now();
+        return session;
+    }
+}
+export const createCoordinatorId = () => {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};