pi-agent-browser-native 0.9.5 → 0.9.7

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

@@ -1,167 +0,0 @@
-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";
-import { presentElectronManagedSessionTarget } from "../browser-run/final-result-electron.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 managedSessions = options.managedSessions.map(presentElectronManagedSessionTarget);
-    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: managedSessions.length === 1 ? managedSessions[0] : undefined,
-            managedSessions: managedSessions.length > 0 ? 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,98 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-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;
-    }
-    run(work, signal, barrier = Promise.resolve()) {
-        if (this.isCurrent()) {
-            signal?.throwIfAborted();
-            return work();
-        }
-        const previous = this.tail;
-        let release;
-        this.tail = new Promise((resolve) => {
-            release = resolve;
-        });
-        let rejectWaiting;
-        const cancelled = new Promise((_resolve, reject) => {
-            rejectWaiting = reject;
-        });
-        const abortWaiting = () => {
-            rejectWaiting(signal?.reason);
-        };
-        signal?.addEventListener("abort", abortWaiting, { once: true });
-        if (signal?.aborted === true) {
-            abortWaiting();
-        }
-        const execution = (async () => {
-            await Promise.all([previous, barrier]);
-            signal?.removeEventListener("abort", abortWaiting);
-            try {
-                signal?.throwIfAborted();
-                const scope = { active: true };
-                try {
-                    return await this.active.run(scope, work);
-                }
-                finally {
-                    scope.active = false;
-                }
-            }
-            finally {
-                release();
-            }
-        })();
-        return signal ? Promise.race([execution, cancelled]) : execution;
-    }
-}
-export class KeyedAsyncExecutionQueue {
-    barriers = new Map();
-    entries = new Map();
-    async run(key, namespace, work, signal) {
-        const entry = this.entries.get(key) ?? { queue: new AsyncExecutionQueue(), users: 0 };
-        if (entry.queue.isCurrent()) {
-            return entry.queue.run(work, signal);
-        }
-        const barrier = this.barriers.get(getAgentBrowserSessionIdentityKey("", namespace)) ?? Promise.resolve();
-        entry.users += 1;
-        this.entries.set(key, entry);
-        try {
-            return await entry.queue.run(work, signal, barrier);
-        }
-        finally {
-            entry.users -= 1;
-            if (entry.users === 0 && this.entries.get(key) === entry) {
-                this.entries.delete(key);
-            }
-        }
-    }
-    async runExclusive(namespace, work) {
-        const namespaceKey = getAgentBrowserSessionIdentityKey("", namespace);
-        const previous = this.barriers.get(namespaceKey) ?? Promise.resolve();
-        let release;
-        const blocked = new Promise((resolve) => {
-            release = resolve;
-        });
-        const barrier = previous.then(() => blocked);
-        this.barriers.set(namespaceKey, barrier);
-        const drains = [...this.entries]
-            .filter(([key]) => isAgentBrowserSessionIdentityKeyInNamespace(key, namespace))
-            .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 {
-            return await work();
-        }
-        finally {
-            release();
-            if (this.barriers.get(namespaceKey) === barrier) {
-                this.barriers.delete(namespaceKey);
-            }
-        }
-    }
-}

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

@@ -1,211 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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;
-}