pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/electron-host/status.js

@@ -0,0 +1,165 @@
+import { inspectElectronLaunchStatus } from "../../electron/cleanup.js";
+import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
+import { buildAgentBrowserNextActions } from "../../results/action-recommendations.js";
+import { buildAgentBrowserResultCategoryDetails } from "../../results/categories.js";
+import { appendUniqueAgentBrowserNextActions } from "../../results/next-actions.js";
+import { redactSensitiveText } from "../../runtime-redaction.js";
+import { getSessionPageStateKey } from "../../session-page-state.js";
+import { buildElectronHostFailureResult, formatElectronTargetLines, redactToolDetails, } from "../browser-run/final-result.js";
+import { buildElectronIdentifiers, buildElectronMismatchNextActions, buildElectronSessionMismatch, formatElectronSessionMismatchText, } from "../browser-run/session-state.js";
+import { selectElectronRecords } from "./branch.js";
+import { collectOwnedElectronManagedSessionTarget } from "./policy.js";
+function pidStatusText(pidAlive) {
+    if (pidAlive === undefined) {
+        return "";
+    }
+    return pidAlive ? ", pid alive" : ", pid dead";
+}
+function formatLaunchHeadline(status, record) {
+    const sessionName = record?.sessionName;
+    const sessionText = sessionName !== undefined && sessionName.length > 0 ? `, sessionName ${sessionName}` : "";
+    const historyText = status.cleanupState === "cleaned" ? "; historical cleaned launch record" : "";
+    return `- ${status.launchId}: ${record?.appName ?? "Electron launch"}${sessionText}${historyText}; ${status.portAlive ? "debug port alive" : "debug port dead"}${pidStatusText(status.pidAlive)} (port ${status.port})`;
+}
+function formatLaunchStatus(status, record, managedSession) {
+    const sessionName = record?.sessionName;
+    const lines = [
+        formatLaunchHeadline(status, record),
+        `  Tracked profile path: ${status.userDataDirState}.`,
+        `  Identifiers: launchId ${status.launchId}; sessionName ${sessionName ?? "not attached"}.`,
+        ...formatElectronTargetLines(status.targets, 4).map((line) => `  ${line}`),
+    ];
+    if (managedSession?.error !== undefined && managedSession.error.length > 0) {
+        lines.push(`  Managed session warning: ${managedSession.error}`);
+    }
+    return lines;
+}
+function formatElectronStatusVisibleText(options) {
+    if (options.statuses.length === 0) {
+        return "Electron status: no active wrapper-tracked launches.";
+    }
+    const recordsByLaunchId = new Map(options.records.map((record) => [record.launchId, record]));
+    const sessionsByName = new Map(options.managedSessions.map((session) => [session.sessionName, session]));
+    const lines = [`Electron status: ${options.statuses.length} wrapper-tracked launch(es).`];
+    for (const status of options.statuses) {
+        const record = recordsByLaunchId.get(status.launchId);
+        const name = record?.sessionName;
+        const session = name !== undefined && name.length > 0 ? sessionsByName.get(name) : undefined;
+        lines.push(...formatLaunchStatus(status, record, session));
+    }
+    for (const mismatch of options.mismatches) {
+        lines.push("", formatElectronSessionMismatchText(mismatch));
+    }
+    return lines.join("\n");
+}
+function statusNextActions(options) {
+    const base = options.records.flatMap((record) => buildAgentBrowserNextActions({
+        electron: {
+            launchId: record.launchId,
+            sessionName: record.sessionName,
+            status: record.cleanupState,
+        },
+        resultCategory: "success",
+        successCategory: "completed",
+    }) ?? []);
+    const mismatch = options.mismatches.flatMap((row) => {
+        const record = options.records.find((candidate) => candidate.launchId === row.launchId);
+        return record ? buildElectronMismatchNextActions(record, row.liveTarget) : [];
+    });
+    return options.mismatches.length > 0
+        ? appendUniqueAgentBrowserNextActions([...mismatch], base)
+        : appendUniqueAgentBrowserNextActions([...base], mismatch);
+}
+function buildElectronStatusResult(options) {
+    const nextActions = statusNextActions(options);
+    const soleRecord = options.records.length === 1 ? options.records[0] : undefined;
+    const details = {
+        args: [],
+        compiledElectron: options.compiledElectron,
+        electron: {
+            action: "status",
+            identifierList: options.records.length > 1 ? options.records.map(buildElectronIdentifiers) : undefined,
+            identifiers: soleRecord ? buildElectronIdentifiers(soleRecord) : undefined,
+            launches: options.records,
+            managedSession: options.managedSessions.length === 1 ? options.managedSessions[0] : undefined,
+            managedSessions: options.managedSessions.length > 0 ? options.managedSessions : undefined,
+            sessionMismatch: options.mismatches.length === 1 ? options.mismatches[0] : undefined,
+            sessionMismatches: options.mismatches.length > 1 ? options.mismatches : undefined,
+            status: "succeeded",
+            statuses: options.statuses,
+            targets: options.statuses.flatMap((status) => status.targets),
+        },
+        nextActions: nextActions.length > 0 ? nextActions : undefined,
+        ...buildAgentBrowserResultCategoryDetails({ args: [], succeeded: true }),
+        summary: options.statuses.length === 0
+            ? "Electron status found no active wrapper-tracked launches."
+            : `Electron status inspected ${options.statuses.length} launch(es).`,
+    };
+    return {
+        content: [
+            { type: "text", text: redactSensitiveText(formatElectronStatusVisibleText(options)) },
+        ],
+        details: redactToolDetails(details, []),
+        isError: false,
+    };
+}
+function collectStatusManagedSessions(options, records, timeoutMs) {
+    return Promise.all(records
+        .filter((record) => typeof record.sessionName === "string")
+        .map((record) => {
+        const key = getSessionPageStateKey(record.sessionName, record.namespace) ?? record.sessionName;
+        const owner = options.ownedManagedSessions.get(key);
+        return collectOwnedElectronManagedSessionTarget({
+            confirmActions: options.sessionPageState.get(key).confirmActions ??
+                getAgentBrowserProcessEnvironment().AGENT_BROWSER_CONFIRM_ACTIONS,
+            cwd: options.cwd,
+            electronLaunchRecord: record,
+            headedManagedAutosaveDisabled: owner?.headedManagedAutosaveDisabled,
+            headedManagedAutosaveInterval: owner?.headedManagedAutosaveInterval,
+            namespace: record.namespace,
+            restoreState: options.managedSessionRestoreState,
+            sessionName: record.sessionName,
+            signal: options.signal,
+            timeoutMs,
+        });
+    }));
+}
+function statusMismatches(records, statuses, managedSessions) {
+    return managedSessions
+        .map((session) => {
+        const record = records.find((candidate) => candidate.sessionName === session.sessionName &&
+            candidate.namespace === session.namespace);
+        const status = record
+            ? statuses.find((candidate) => candidate.launchId === record.launchId)
+            : undefined;
+        return record && status
+            ? buildElectronSessionMismatch({
+                managedSession: session,
+                record,
+                statusTargets: status.targets,
+            })
+            : undefined;
+    })
+        .filter((mismatch) => mismatch !== undefined);
+}
+export async function inspectElectronHostLaunches(options, compiledElectron, visibleInput) {
+    const selection = selectElectronRecords(compiledElectron, options.electronLaunchRecords);
+    if (selection.error !== undefined && selection.error.length > 0) {
+        return buildElectronHostFailureResult({
+            compiledElectron: visibleInput,
+            errorText: selection.error,
+            failureCategory: "validation-error",
+        });
+    }
+    const records = selection.records ?? [];
+    const statuses = await Promise.all(records.map((record) => inspectElectronLaunchStatus(record)));
+    const managedSessions = await collectStatusManagedSessions(options, records, compiledElectron.timeoutMs);
+    const mismatches = statusMismatches(records, statuses, managedSessions);
+    return buildElectronStatusResult({
+        compiledElectron: visibleInput,
+        managedSessions,
+        mismatches,
+        records,
+        statuses,
+    });
+}

package/dist/extensions/agent-browser/lib/orchestration/execution-queue.js

@@ -1,10 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "../argv-grammar.js";
+import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "../argv-grammar.js";
 // Serializes managed-session read/modify/write work so overlapping tool calls cannot promote stale state or close an in-use session.
 export class AsyncExecutionQueue {
     tail = Promise.resolve();
     active = new AsyncLocalStorage();
-    isCurrent() { return this.active.getStore()?.active === true; }
+    isCurrent() {
+        return this.active.getStore()?.active === true;
+    }
     run(work, signal, barrier = Promise.resolve()) {
         if (this.isCurrent()) {
             signal?.throwIfAborted();
@@ -16,11 +18,16 @@ export class AsyncExecutionQueue {
             release = resolve;
         });
         let rejectWaiting;
-        const cancelled = new Promise((_resolve, reject) => { rejectWaiting = reject; });
-        const abortWaiting = () => rejectWaiting(signal?.reason);
+        const cancelled = new Promise((_resolve, reject) => {
+            rejectWaiting = reject;
+        });
+        const abortWaiting = () => {
+            rejectWaiting(signal?.reason);
+        };
         signal?.addEventListener("abort", abortWaiting, { once: true });
-        if (signal?.aborted)
+        if (signal?.aborted === true) {
             abortWaiting();
+        }
         const execution = (async () => {
             await Promise.all([previous, barrier]);
             signal?.removeEventListener("abort", abortWaiting);
@@ -46,8 +53,9 @@ export class KeyedAsyncExecutionQueue {
     entries = new Map();
     async run(key, namespace, work, signal) {
         const entry = this.entries.get(key) ?? { queue: new AsyncExecutionQueue(), users: 0 };
-        if (entry.queue.isCurrent())
+        if (entry.queue.isCurrent()) {
             return work();
+        }
         const barrier = this.barriers.get(getAgentBrowserSessionIdentityKey("", namespace)) ?? Promise.resolve();
         entry.users += 1;
         this.entries.set(key, entry);
@@ -56,8 +64,9 @@ export class KeyedAsyncExecutionQueue {
         }
         finally {
             entry.users -= 1;
-            if (entry.users === 0 && this.entries.get(key) === entry)
+            if (entry.users === 0 && this.entries.get(key) === entry) {
                 this.entries.delete(key);
+            }
         }
     }
     async runExclusive(namespace, work) {
@@ -71,7 +80,9 @@ export class KeyedAsyncExecutionQueue {
         this.barriers.set(namespaceKey, barrier);
         const drains = [...this.entries]
             .filter(([key]) => isAgentBrowserSessionIdentityKeyInNamespace(key, namespace))
-            .map(([, { queue }]) => queue.run(async () => undefined));
+            .map(([, { queue }]) => queue.run(async () => {
+            // This queued marker only waits for earlier work; it has no browser operation.
+        }));
         await previous;
         await Promise.all(drains);
         try {
@@ -79,8 +90,9 @@ export class KeyedAsyncExecutionQueue {
         }
         finally {
             release();
-            if (this.barriers.get(namespaceKey) === barrier)
+            if (this.barriers.get(namespaceKey) === barrier) {
                 this.barriers.delete(namespaceKey);
+            }
         }
     }
 }

package/dist/extensions/agent-browser/lib/orchestration/extension-artifact-preflight.js

@@ -0,0 +1,211 @@
+import { extractUpstreamCommandTokens, validateToolArgs } from "../runtime.js";
+import { isCloseAllCommand, isCloseCommand } from "../command-taxonomy.js";
+import { canonicalizeExplicitArtifactDestination, getExplicitArtifactDestination, getRecordContactSheetDestination, } from "./browser-run/artifact-paths.js";
+import { parseBatchCommandArgument, parseUserBatchStdin } from "./batch-stdin.js";
+import { normalizeRequestedOutputPath } from "./output-file.js";
+function parseRawArtifactSteps(commands) {
+    const steps = [];
+    for (const command of commands) {
+        if (command === "--bail") {
+            continue;
+        }
+        const parsed = parseBatchCommandArgument(command);
+        if ((parsed.error !== undefined && parsed.error !== "") || !parsed.step) {
+            return {
+                batch: true,
+                error: `Unsupported batch step ${steps.length + 1}: ${parsed.error ?? "command could not be parsed safely"}`,
+                steps,
+            };
+        }
+        steps.push(parsed.step);
+    }
+    return { batch: true, steps };
+}
+export function getArtifactCommandSteps(args, stdin) {
+    const tokens = extractUpstreamCommandTokens([...args]);
+    if (tokens[0] !== "batch") {
+        return { batch: false, steps: tokens.length > 0 ? [tokens] : [] };
+    }
+    const parsed = parseRawArtifactSteps(tokens.slice(1));
+    if (parsed.error !== undefined && parsed.error !== "") {
+        return parsed;
+    }
+    // Raw native rows exclusively win over stdin, including artifact and lifecycle preflight.
+    if (parsed.steps.length > 0) {
+        return parsed;
+    }
+    const input = parseUserBatchStdin(stdin);
+    return input.error !== undefined && input.error !== ""
+        ? { batch: true, error: input.error, steps: [] }
+        : { batch: true, steps: input.steps ?? [] };
+}
+class ArtifactPreflight {
+    options;
+    active = new Set();
+    destinations = new Map();
+    plan;
+    canonicalOutputPath;
+    sawClose = false;
+    constructor(options) {
+        this.options = options;
+        this.plan = getArtifactCommandSteps(options.args, options.stdin);
+    }
+    cleanupOnly() {
+        return (this.plan.steps.length > 0 &&
+            this.plan.steps.every(([command, subcommand]) => isCloseCommand(command) || (command === "record" && subcommand === "stop")));
+    }
+    reserveActiveDestinations() {
+        for (const reservation of this.options.activeRecordingReservations ?? []) {
+            try {
+                this.active.add(canonicalizeExplicitArtifactDestination(reservation.cwd, reservation.absolutePath));
+                if (reservation.contactSheetPath !== undefined && reservation.contactSheetPath !== "") {
+                    this.active.add(canonicalizeExplicitArtifactDestination(reservation.cwd, reservation.contactSheetPath));
+                }
+            }
+            catch (error) {
+                if (!this.cleanupOnly()) {
+                    return error instanceof Error
+                        ? error.message
+                        : "An active recording destination could not be resolved safely.";
+                }
+            }
+        }
+        return undefined;
+    }
+    validateOutputPath() {
+        const path = this.options.outputPath;
+        if (path === undefined || path === "") {
+            return undefined;
+        }
+        try {
+            this.canonicalOutputPath = canonicalizeExplicitArtifactDestination(this.options.cwd, normalizeRequestedOutputPath(path));
+            if (this.active.has(this.canonicalOutputPath)) {
+                return `Unsupported outputPath: ${path} is reserved by an active recording. Stop that recording first or use a distinct path.`;
+            }
+        }
+        catch (error) {
+            return error instanceof Error
+                ? error.message
+                : `outputPath ${path} could not be resolved safely.`;
+        }
+        return undefined;
+    }
+    validateBatchStep(step, index) {
+        if (!this.plan.batch) {
+            return undefined;
+        }
+        const error = validateToolArgs([...step], { batchStep: true });
+        if (error !== undefined && error !== "") {
+            return `Unsupported batch step ${index + 1}: ${error}`;
+        }
+        if (this.sawClose && step[0] === "record" && (step[1] === "start" || step[1] === "restart")) {
+            return `Unsupported batch step ${index + 1}: record ${step[1]} cannot follow close, quit, or exit in one upstream batch because upstream can report success without starting a recording. Split the close and recording into separate agent_browser calls.`;
+        }
+        if (isCloseCommand(step[0])) {
+            this.sawClose = true;
+        }
+        return undefined;
+    }
+    validateDestination(destination, index) {
+        let canonical;
+        try {
+            canonical = canonicalizeExplicitArtifactDestination(this.options.cwd, destination);
+        }
+        catch (error) {
+            return error instanceof Error
+                ? error.message
+                : `Artifact destination ${destination} could not be resolved safely.`;
+        }
+        if (this.canonicalOutputPath === canonical) {
+            return `Unsupported outputPath: ${this.options.outputPath ?? ""} resolves to the same destination as artifact path ${destination}. Use distinct paths so the tool-result JSON cannot overwrite the browser artifact.`;
+        }
+        if (this.active.has(canonical)) {
+            const prefix = this.plan.batch
+                ? `Unsupported batch artifact destination in step ${index + 1}`
+                : "Unsupported artifact destination";
+            return `${prefix}: ${destination} is reserved by an active recording. Stop that recording first or use a distinct path.`;
+        }
+        const prior = this.destinations.get(canonical);
+        if (prior !== undefined) {
+            return `Unsupported batch artifact destination in step ${index + 1}: ${destination} is already written by step ${prior + 1}. Use distinct paths or split the batch so each artifact can be verified independently.`;
+        }
+        this.destinations.set(canonical, index);
+        return undefined;
+    }
+    validateStepDestinations(step, index) {
+        for (const destination of [
+            getExplicitArtifactDestination([...step]),
+            getRecordContactSheetDestination([...step]),
+        ]) {
+            if (destination === undefined || destination === "") {
+                continue;
+            }
+            const failure = this.validateDestination(destination, index);
+            if (failure !== undefined && failure !== "") {
+                return failure;
+            }
+        }
+        return undefined;
+    }
+    validateStep(step, index) {
+        if (step.length === 0) {
+            return undefined;
+        }
+        const error = this.validateBatchStep(step, index);
+        if (error !== undefined && error !== "") {
+            return error;
+        }
+        const destinationFailure = this.validateStepDestinations(step, index);
+        if (destinationFailure !== undefined && destinationFailure !== "") {
+            return destinationFailure;
+        }
+        if (this.plan.batch && step[0] === "screenshot" && step.includes("--annotate")) {
+            return [
+                `Unsupported batch screenshot annotation in step ${index + 1}: put --annotate in top-level args, not inside the batch step.`,
+                `Use: { "args": ["--annotate", "batch"], "stdin": "[[\\"screenshot\\",\\"/path/to/image.png\\"]]" }`,
+            ].join("\n");
+        }
+        return undefined;
+    }
+    run() {
+        const error = this.plan.error;
+        if (error !== undefined && error !== "") {
+            return error;
+        }
+        const activeError = this.reserveActiveDestinations();
+        if (activeError !== undefined && activeError !== "") {
+            return activeError;
+        }
+        const outputError = this.validateOutputPath();
+        if (outputError !== undefined && outputError !== "") {
+            return outputError;
+        }
+        for (const [index, step] of this.plan.steps.entries()) {
+            const failure = this.validateStep(step, index);
+            if (failure !== undefined && failure !== "") {
+                return failure;
+            }
+        }
+        return undefined;
+    }
+}
+export function getArtifactPreflightValidationError(options) {
+    return new ArtifactPreflight(options).run();
+}
+export function commandClosesAllSessions(args, stdin) {
+    const parsed = getArtifactCommandSteps(args, stdin);
+    return ((parsed.error === undefined || parsed.error === "") && parsed.steps.some(isCloseAllCommand));
+}
+export function commandTouchesArtifactLifecycle(args, stdin, outputPath) {
+    if (outputPath !== undefined && outputPath !== "") {
+        return true;
+    }
+    const parsed = getArtifactCommandSteps(args, stdin);
+    if (parsed.error !== undefined && parsed.error !== "") {
+        return true;
+    }
+    return parsed.steps.some((step) => getExplicitArtifactDestination(step) !== undefined ||
+        step[0] === "record" ||
+        step[0] === "screenshot" ||
+        isCloseCommand(step[0]));
+}

package/dist/extensions/agent-browser/lib/orchestration/extension-artifacts.js

@@ -0,0 +1,23 @@
+import { retirePendingRecordingManifestEntries } from "../results/artifact-manifest.js";
+import { mergeBrowserRunArtifactManifest } from "./browser-run/artifact-merge.js";
+import { AsyncExecutionQueue } from "./execution-queue.js";
+/** One extension's artifact publication queue and bounded manifest. */
+export class BrowserArtifacts {
+    pi;
+    queue = new AsyncExecutionQueue();
+    manifest;
+    constructor(pi) {
+        this.pi = pi;
+    }
+    commit(prior, rendered) {
+        this.manifest = mergeBrowserRunArtifactManifest(this.manifest, prior, rendered);
+        return this.manifest;
+    }
+    retireRecording(sessionName, namespace) {
+        const previous = this.manifest;
+        if (this.manifest) {
+            this.manifest = retirePendingRecordingManifestEntries(this.manifest, sessionName, namespace);
+        }
+        return this.manifest !== previous;
+    }
+}

package/dist/extensions/agent-browser/lib/orchestration/extension-attachment-replay.js

@@ -0,0 +1,99 @@
+import { getSuccessfulBatchCloseLifecycle } from "../batch-lifecycle.js";
+import { getBrowserResultMessage } from "../browser-transcript.js";
+import { extractExplicitNamespace, extractExplicitSessionName, deleteIdentityKeysInNamespace, } from "../argv-grammar.js";
+import { extractUpstreamCommandTokens } from "../runtime.js";
+import { isCloseCommand } from "../command-taxonomy.js";
+import { isSuccessfulNativeConfirmedClose } from "../read-confirmation.js";
+import { isRecord } from "../parsing.js";
+import { getSessionContextKey } from "./browser-run/session-state.js";
+import { getCleanupResultClosedManagedSessionIdentities } from "./extension-electron-ownership.js";
+import { getToolResultArgs, getSuccessfulToolResult, detailsReportCloseAllApplied, isAttachedBrowserInvocation, } from "./extension-resource-replay.js";
+function parseAttachmentRow(entry) {
+    const message = getBrowserResultMessage(entry);
+    const details = isRecord(message?.details) ? message.details : undefined;
+    if (!message || !details) {
+        return undefined;
+    }
+    const outcome = isRecord(details.managedSessionOutcome)
+        ? details.managedSessionOutcome
+        : undefined;
+    const args = getToolResultArgs(details);
+    return {
+        details,
+        args,
+        succeeded: getSuccessfulToolResult(details, message),
+        batchCloseLifecycle: getSuccessfulBatchCloseLifecycle(details.batchSteps),
+        namespace: typeof details.namespace === "string" ? details.namespace : extractExplicitNamespace(args),
+        sessionName: typeof details.sessionName === "string"
+            ? details.sessionName
+            : extractExplicitSessionName(args),
+        retainedFailedAttachment: details.attachedBrowserSession === true && outcome?.activeAfter === true,
+    };
+}
+class AttachmentReplay {
+    keys = new Set();
+    cleanupElectron(row) {
+        const electron = isRecord(row.details.electron) ? row.details.electron : undefined;
+        const cleanup = isRecord(electron?.cleanup) ? electron.cleanup : undefined;
+        for (const result of Array.isArray(cleanup?.results) ? cleanup.results : []) {
+            for (const identity of getCleanupResultClosedManagedSessionIdentities(result, row.namespace)) {
+                this.keys.delete(getSessionContextKey(identity.sessionName, identity.namespace) ?? identity.sessionName);
+            }
+        }
+    }
+    restoreCloseAll(row) {
+        if (!detailsReportCloseAllApplied(row.details, row.succeeded)) {
+            return false;
+        }
+        deleteIdentityKeysInNamespace(this.keys, row.namespace);
+        if (row.sessionName !== undefined &&
+            row.sessionName !== "" &&
+            row.details.attachedBrowserSession === true &&
+            row.batchCloseLifecycle?.endsClosed === false) {
+            this.keys.add(getSessionContextKey(row.sessionName, row.namespace) ?? row.sessionName);
+        }
+        return true;
+    }
+    closesAttachment(row) {
+        if (row.batchCloseLifecycle?.endsClosed === true) {
+            return true;
+        }
+        const tokens = extractUpstreamCommandTokens([...row.args]);
+        const command = typeof row.details.command === "string" ? row.details.command : tokens[0];
+        return (row.succeeded &&
+            (isCloseCommand(command) || isSuccessfulNativeConfirmedClose(tokens, row.details.data)));
+    }
+    canRestore(row) {
+        return (row.succeeded || row.retainedFailedAttachment || row.batchCloseLifecycle?.endsClosed === true);
+    }
+    apply(row) {
+        this.cleanupElectron(row);
+        if (this.restoreCloseAll(row)) {
+            return;
+        }
+        if (!this.canRestore(row)) {
+            return;
+        }
+        if (row.sessionName === undefined || row.sessionName === "") {
+            return;
+        }
+        const key = getSessionContextKey(row.sessionName, row.namespace) ?? row.sessionName;
+        if (this.closesAttachment(row)) {
+            this.keys.delete(key);
+        }
+        else if (row.details.attachedBrowserSession === true ||
+            isAttachedBrowserInvocation(row.args, {})) {
+            this.keys.add(key);
+        }
+    }
+}
+export function restoreAttachedSessionKeysFromBranch(branch) {
+    const replay = new AttachmentReplay();
+    for (const entry of branch) {
+        const row = parseAttachmentRow(entry);
+        if (row) {
+            replay.apply(row);
+        }
+    }
+    return replay.keys;
+}