pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-inspection.js

@@ -1,108 +0,0 @@
-import { rm } from "node:fs/promises";
-import { isRecord } from "../../parsing.js";
-import { resolveExplicitAutosaveInterval } from "../../managed-session-restore.js";
-import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
-import { readProcessStartIdentity } from "../../process-identity.js";
-import { runAgentBrowserProcess } from "../../process.js";
-import { parseAgentBrowserEnvelope } from "../../results/envelope.js";
-const MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS = 35_000;
-const RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR = 'AGENT_BROWSER_AUTOSAVE_INTERVAL_MS cannot change a running wrapper-owned headed session\'s launch-time periodic autosave interval. Close that session first, then retry with sessionMode: "fresh" so the new daemon starts with the requested interval.';
-export function getRunningHeadedAutosavePolicyChangeError(recordedInterval, closeCommand = false) {
-    const explicitInterval = resolveExplicitAutosaveInterval(getAgentBrowserProcessEnvironment().AGENT_BROWSER_AUTOSAVE_INTERVAL_MS);
-    return recordedInterval !== undefined &&
-        !closeCommand &&
-        explicitInterval !== undefined &&
-        explicitInterval !== recordedInterval
-        ? RUNNING_HEADED_AUTOSAVE_POLICY_CHANGE_ERROR
-        : undefined;
-}
-export function getHeadedManagedAutosaveEnv(interval) {
-    return interval !== undefined ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: interval } : undefined;
-}
-async function readDaemonGeneration(runtime, options) {
-    if (options.includeGeneration !== true ||
-        typeof runtime.backgroundPid !== "number" ||
-        !Number.isSafeInteger(runtime.backgroundPid) ||
-        runtime.backgroundPid <= 0 ||
-        typeof runtime.socketDir !== "string" ||
-        runtime.browserLaunched === false) {
-        return undefined;
-    }
-    const start = await readProcessStartIdentity(runtime.backgroundPid, process.platform, {
-        signal: options.signal,
-        deadline: Date.now() + (options.timeoutMs ?? 5_000),
-    });
-    return start !== undefined && start !== ""
-        ? JSON.stringify({
-            pid: runtime.backgroundPid,
-            start,
-            socketDir: runtime.socketDir,
-        })
-        : undefined;
-}
-async function parseDaemonInspection(data, options) {
-    if (!isRecord(data) || typeof data.active !== "boolean") {
-        return { status: "unknown" };
-    }
-    if (!data.active) {
-        return { status: "inactive" };
-    }
-    if (!isRecord(data.runtime)) {
-        return { status: "unknown" };
-    }
-    const generation = await readDaemonGeneration(data.runtime, options);
-    if (typeof data.runtime.restoreKey === "string" && data.runtime.restoreKey.length > 0) {
-        return { restoreKey: data.runtime.restoreKey, status: "active", generation };
-    }
-    return data.runtime.restoreKey === null
-        ? { restoreKey: null, status: "active", generation }
-        : { status: "unknown" };
-}
-function daemonProcessFailure(processResult) {
-    if (processResult.spawnError &&
-        "code" in processResult.spawnError &&
-        processResult.spawnError.code === "ENOENT") {
-        return { status: "missing-binary" };
-    }
-    return processResult.aborted || processResult.spawnError || processResult.exitCode !== 0
-        ? { status: "unknown" }
-        : undefined;
-}
-async function readDaemonInfo(processResult) {
-    const parsed = await parseAgentBrowserEnvelope({
-        stdout: processResult.stdout,
-        stdoutPath: processResult.stdoutSpillPath,
-    });
-    return (parsed.parseError ?? "") !== "" || parsed.envelope?.success === false
-        ? undefined
-        : parsed.envelope?.data;
-}
-export async function inspectManagedSessionDaemon(options) {
-    const processResult = await runAgentBrowserProcess({
-        args: [
-            "--json",
-            "--namespace",
-            options.namespace ?? "",
-            "--session",
-            options.sessionName,
-            "session",
-            "info",
-        ],
-        cwd: options.cwd,
-        env: getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval),
-        preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
-        signal: options.signal,
-        timeoutMs: options.timeoutMs ?? MANAGED_SESSION_DAEMON_INSPECTION_TIMEOUT_MS,
-    });
-    try {
-        const failure = daemonProcessFailure(processResult);
-        return failure ?? (await parseDaemonInspection(await readDaemonInfo(processResult), options));
-    }
-    finally {
-        if (processResult.stdoutSpillPath !== undefined && processResult.stdoutSpillPath !== "") {
-            await rm(processResult.stdoutSpillPath, { force: true }).catch(() => {
-                // Spill cleanup is best-effort and must not change the daemon inspection result.
-            });
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/managed-session-daemon-policy.js

@@ -1,174 +0,0 @@
-import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
-import { inspectElectronLaunchStatus } from "../../electron/cleanup.js";
-import { acquireManagedSessionPolicyLock, } from "../../managed-session-policy-lock.js";
-import { withOwnedManagedSessionContext, } from "../../managed-session-restore.js";
-import { isRecord } from "../../parsing.js";
-import { withAttachedBrowserSessionContext } from "../../process.js";
-import { runSessionCommandData } from "./session-state.js";
-import { getHeadedManagedAutosaveEnv, inspectManagedSessionDaemon, } from "./managed-session-daemon-inspection.js";
-export { closeManagedSession } from "./managed-session-close.js";
-export { getRunningHeadedAutosavePolicyChangeError, inspectManagedSessionDaemon, } from "./managed-session-daemon-inspection.js";
-function hasElectronAttachmentIdentity(record) {
-    return (record.webSocketDebuggerUrl !== undefined &&
-        record.webSocketDebuggerUrl !== "" &&
-        record.sessionName !== undefined &&
-        record.sessionName !== "");
-}
-function restoredAttachmentTarget(context, record) {
-    const cwd = context.cwd;
-    if (cwd === undefined || cwd === "" || !record || !hasElectronAttachmentIdentity(record)) {
-        return undefined;
-    }
-    if (record.cleanupState === "cleaned" ||
-        getAgentBrowserSessionIdentityKey(record.sessionName ?? "", record.namespace) !==
-            getAgentBrowserSessionIdentityKey(context.sessionName, context.namespace)) {
-        return undefined;
-    }
-    return { cwd, record };
-}
-function attachmentStatusMatches(record, status) {
-    return (status.pidAlive === true &&
-        status.userDataDirState === "present" &&
-        status.version?.webSocketDebuggerUrl === record.webSocketDebuggerUrl);
-}
-function attachmentConnectionMatches(connection, record, status) {
-    return (isRecord(connection) &&
-        typeof connection.cdpUrl === "string" &&
-        (connection.cdpUrl === record.webSocketDebuggerUrl ||
-            status.targets.some((target) => target.webSocketDebuggerUrl === connection.cdpUrl)));
-}
-async function verifyRestoredElectronAttachment(options) {
-    const { context, signal } = options;
-    const attachment = restoredAttachmentTarget(context, options.electronLaunchRecord);
-    if (!attachment) {
-        return false;
-    }
-    const status = await inspectElectronLaunchStatus(attachment.record, signal);
-    if (signal?.aborted === true || !attachmentStatusMatches(attachment.record, status)) {
-        return false;
-    }
-    // This metadata probe must not grant daemon provenance just by spawning.
-    const connection = await withAttachedBrowserSessionContext(true, () => withOwnedManagedSessionContext(undefined, () => runSessionCommandData({
-        args: ["get", "cdp-url"],
-        cwd: attachment.cwd,
-        env: getHeadedManagedAutosaveEnv(context.headedManagedAutosaveInterval),
-        namespace: context.namespace,
-        pinNamespace: true,
-        sessionName: context.sessionName,
-        signal,
-        timeoutMs: options.electronVerificationTimeoutMs,
-    })));
-    return (
-    // The abort callback can change this signal during the awaited CDP read; static narrowing does not model it.
-    // oxlint-disable-next-line typescript/no-unnecessary-condition
-    !(signal?.aborted ?? false) &&
-        attachmentConnectionMatches(connection, attachment.record, status));
-}
-function reconcileDaemonReceipt(context, daemon, receipt) {
-    if (daemon.status === "inactive") {
-        context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
-    }
-    if (daemon.status !== "active" ||
-        receipt === undefined ||
-        context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace)) {
-        return;
-    }
-    if (daemon.generation === receipt.generation && daemon.restoreKey === receipt.restoreKey) {
-        context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey, daemon.generation);
-    }
-    else {
-        context.restoreState.forgetDaemonRestoreKey(context.sessionName, context.namespace);
-    }
-}
-function daemonPolicyMismatch(daemon, restoreDisabledPolicyNeedsProvenance, hasKnownDaemonRestoreKey) {
-    return {
-        cleanupOnlyReason: daemon.status === "active" &&
-            restoreDisabledPolicyNeedsProvenance &&
-            !hasKnownDaemonRestoreKey
-            ? "restore-disabled-daemon-without-provenance"
-            : undefined,
-        daemonStatus: daemon.status,
-        error: [
-            "This wrapper-owned session's live daemon does not match the requested managed-restore policy.",
-            'Close that session first, retry with sessionMode: "fresh", or use a distinct explicit --session.',
-        ].join(" "),
-    };
-}
-async function validateReusableDaemonPolicy(options, daemon) {
-    const { context } = options;
-    const stickyDisabled = context.restoreState.isDisabled(context.sessionName, context.namespace);
-    let hasKnownDaemonRestoreKey = context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace);
-    const knownDaemonRestoreKey = context.restoreState.getDaemonRestoreKey(context.sessionName, context.namespace);
-    const requestedDaemonRestoreKey = context.restoreDecision === "enabled" && stickyDisabled
-        ? (knownDaemonRestoreKey ?? null)
-        : context.expectedDaemonRestoreKey;
-    if (daemon.status === "unknown") {
-        return {
-            error: 'The wrapper could not verify this managed session\'s live daemon restore policy. Retry, close that session, or use sessionMode: "fresh".',
-        };
-    }
-    const restoreDisabledPolicyNeedsProvenance = stickyDisabled || context.restoreDecision !== "enabled";
-    if (daemon.status === "active" &&
-        restoreDisabledPolicyNeedsProvenance &&
-        !hasKnownDaemonRestoreKey &&
-        daemon.restoreKey === requestedDaemonRestoreKey) {
-        hasKnownDaemonRestoreKey = await verifyRestoredElectronAttachment(options);
-    }
-    return finishReusableDaemonPolicy(context, daemon, {
-        restoreDisabledPolicyNeedsProvenance,
-        requestedDaemonRestoreKey,
-    }, hasKnownDaemonRestoreKey);
-}
-function finishReusableDaemonPolicy(context, daemon, policy, hasKnownDaemonRestoreKey) {
-    const activePolicyMatches = daemon.status === "active" &&
-        (!policy.restoreDisabledPolicyNeedsProvenance || hasKnownDaemonRestoreKey) &&
-        daemon.restoreKey === policy.requestedDaemonRestoreKey;
-    if (activePolicyMatches) {
-        context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
-    }
-    return !["inactive", "missing-binary"].includes(daemon.status) && !activePolicyMatches
-        ? daemonPolicyMismatch(daemon, policy.restoreDisabledPolicyNeedsProvenance, hasKnownDaemonRestoreKey)
-        : { daemonStatus: daemon.status };
-}
-export async function acquireOwnedManagedSessionDaemonPolicy(options) {
-    const { context, signal } = options;
-    if (context.cwd === undefined || context.cwd === "") {
-        return { error: "Managed-session policy validation requires the wrapper-owned session cwd." };
-    }
-    const lock = await acquireManagedSessionPolicyLock({
-        namespace: context.namespace,
-        sessionName: context.sessionName,
-        signal,
-    });
-    if (!lock) {
-        return signal?.aborted === true
-            ? {}
-            : {
-                error: "Managed-session policy coordination is unavailable or busy. Retry after the current operation finishes, repair the private policy-lock directory, and on POSIX verify that /bin/ps, /usr/bin/ps, or ps through PATH is available.",
-            };
-    }
-    try {
-        const receipt = context.restoreState.getDaemonReceipt(context.sessionName, context.namespace);
-        const daemon = await inspectManagedSessionDaemon({
-            cwd: context.cwd,
-            includeGeneration: receipt !== undefined &&
-                !context.restoreState.hasDaemonRestoreKey(context.sessionName, context.namespace),
-            headedManagedAutosaveInterval: context.headedManagedAutosaveInterval,
-            namespace: context.namespace,
-            sessionName: context.sessionName,
-            signal,
-        });
-        reconcileDaemonReceipt(context, daemon, receipt);
-        if (options.mode === "close") {
-            if (daemon.status === "active") {
-                context.restoreState.recordDaemonRestoreKey(context.sessionName, context.namespace, daemon.restoreKey);
-            }
-            return { daemonStatus: daemon.status, lock };
-        }
-        return { ...(await validateReusableDaemonPolicy(options, daemon)), lock };
-    }
-    catch (error) {
-        await lock.release();
-        throw error;
-    }
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/native-helper-observation.js

@@ -1,65 +0,0 @@
-import { getAgentBrowserSessionIdentityKey, resolveAgentBrowserNamespace, } from "../../argv-grammar.js";
-import { parseArgvDescriptor } from "../../argv-descriptor.js";
-import { isBrowserIndependentRead, needsManagedSession } from "../../command-policy.js";
-import { getAgentBrowserProcessEnvironment } from "../../process-environment.js";
-import { nextReadConfirmation, parseReadConfirmation } from "../../read-confirmation.js";
-import { nativePolicyDefinitelyUnestablished, } from "./session-state.js";
-function helperNamespace(helper) {
-    return resolveAgentBrowserNamespace([], helper.namespace ?? getAgentBrowserProcessEnvironment().AGENT_BROWSER_NAMESPACE);
-}
-function helperMayRun(helper, effects) {
-    const pending = parseReadConfirmation(effects?.readConfirmation);
-    return ((!needsManagedSession(parseArgvDescriptor(helper.args), helper.stdin) &&
-        !isBrowserIndependentRead(helper.args, helper.stdin)) ||
-        pending?.state !== "pending" ||
-        getAgentBrowserSessionIdentityKey(helper.sessionName ?? "default", helperNamespace(helper)) !==
-            getAgentBrowserSessionIdentityKey(pending.sessionName, pending.namespace));
-}
-function helperSucceeded(observation) {
-    return (observation.envelope?.success === true &&
-        observation.processResult.exitCode === 0 &&
-        !observation.processResult.aborted &&
-        !observation.processResult.timedOut);
-}
-function markPendingOpenTargetUnknown(state, update, key) {
-    const invalidation = state.sessionPageState.get(key).refSnapshotInvalidation;
-    state.sessionPageState.markTabTargetUnknown({ sessionName: key, update });
-    if (invalidation) {
-        state.sessionPageState.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation });
-    }
-}
-function applyHelperConfirmation(state, update, observation) {
-    const { helper, envelope, processResult } = observation;
-    const namespace = helperNamespace(helper);
-    const sessionName = helper.sessionName ?? "default";
-    const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
-    if (key === state.confirmationPolicyIdentity &&
-        !nativePolicyDefinitelyUnestablished(processResult, envelope, helper.args)) {
-        state.confirmationPolicyMayBeEstablished = true;
-    }
-    const confirmation = nextReadConfirmation({
-        commandTokens: helper.args,
-        current: state.sessionPageState.getReadConfirmation(key),
-        data: envelope?.data,
-        namespace,
-        sessionName,
-        succeeded: helperSucceeded(observation),
-    });
-    if (!confirmation) {
-        return;
-    }
-    state.sessionPageState.applyReadConfirmation(confirmation, update);
-    if (helper.args[0] === "open" && confirmation.state === "pending") {
-        markPendingOpenTargetUnknown(state, update, key);
-    }
-    state.observedBrowserEffects = {
-        ...state.observedBrowserEffects,
-        readConfirmation: confirmation,
-    };
-}
-export function createNativeHelperObserver(state, update) {
-    return {
-        allow: (helper) => helperMayRun(helper, state.observedBrowserEffects),
-        observe: (helper, processResult, envelope) => applyHelperConfirmation(state, update, { helper, processResult, envelope }),
-    };
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/observation-types.js

@@ -1 +0,0 @@
-export {};

package/dist/extensions/agent-browser/lib/orchestration/browser-run/overlay-diagnostics.js

@@ -1,120 +0,0 @@
-import { isRecord } from "../../parsing.js";
-import { buildInspectOverlayStateAction, withOptionalSessionArgs, } from "../../results/next-actions.js";
-import { extractRefSnapshotFromData, normalizeComparableUrl, } from "../../session-page-state.js";
-import { rawStringField } from "./diagnostic-values.js";
-import { runSessionCommandData } from "./session-state.js";
-const OVERLAY_CLOSE_NAME_PATTERN = /(?:\b(?:close|dismiss|no thanks|not now|maybe later|hide|skip|continue without|x)\b|^\s*×\s*$)/i;
-const OVERLAY_CONTEXT_ROLES = new Set(["alertdialog", "dialog"]);
-const OVERLAY_ACTION_ROLES = new Set(["button", "link", "menuitem"]);
-const OVERLAY_BLOCKER_CANDIDATE_LIMIT = 3;
-function overlayBlockerCandidate(ref, entry) {
-    if (!/^e\d+$/.test(ref) || !isRecord(entry)) {
-        return undefined;
-    }
-    const role = rawStringField(entry, "role");
-    const name = rawStringField(entry, "name");
-    if (role === undefined ||
-        role === "" ||
-        !OVERLAY_ACTION_ROLES.has(role.toLowerCase()) ||
-        name === undefined ||
-        name === "" ||
-        !OVERLAY_CLOSE_NAME_PATTERN.test(name)) {
-        return undefined;
-    }
-    return {
-        args: ["click", `@${ref}`],
-        name,
-        reason: `Visible ${role} ${JSON.stringify(name)} appears in a snapshot that also contains overlay/banner/dialog context.`,
-        ref: `@${ref}`,
-        role,
-    };
-}
-function getOverlayBlockerCandidates(snapshotData) {
-    const refs = isRecord(snapshotData) && isRecord(snapshotData.refs) ? snapshotData.refs : undefined;
-    if (!refs ||
-        !Object.values(refs).some((entry) => isRecord(entry) &&
-            OVERLAY_CONTEXT_ROLES.has((rawStringField(entry, "role") ?? "").toLowerCase()))) {
-        return [];
-    }
-    const candidates = [];
-    for (const [ref, entry] of Object.entries(refs)) {
-        const candidate = overlayBlockerCandidate(ref, entry);
-        if (candidate) {
-            candidates.push(candidate);
-        }
-        if (candidates.length >= OVERLAY_BLOCKER_CANDIDATE_LIMIT) {
-            break;
-        }
-    }
-    return candidates;
-}
-export function formatOverlayBlockerText(diagnostic) {
-    return [
-        "Possible overlay blockers:",
-        ...diagnostic.candidates.map((candidate) => {
-            const role = candidate.role !== undefined && candidate.role !== "" ? ` ${candidate.role}` : "";
-            const name = candidate.name !== undefined && candidate.name !== ""
-                ? ` ${JSON.stringify(candidate.name)}`
-                : "";
-            return `- ${candidate.ref}${role}${name}: ${candidate.reason}`;
-        }),
-    ].join("\n");
-}
-export function buildOverlayBlockerNextActions(options) {
-    return [
-        buildInspectOverlayStateAction(options.sessionName),
-        ...options.diagnostic.candidates.map((candidate, index) => ({
-            id: `try-overlay-blocker-candidate-${index + 1}`,
-            params: { args: withOptionalSessionArgs(options.sessionName, candidate.args) },
-            reason: candidate.reason,
-            safety: "Only click this if the candidate is clearly a close/dismiss control for an overlay that blocks the intended workflow.",
-            tool: "agent_browser",
-        })),
-    ];
-}
-export function collectSnapshotOverlayBlockerDiagnostic(data) {
-    const candidates = getOverlayBlockerCandidates(data);
-    const snapshot = extractRefSnapshotFromData(data);
-    return candidates.length === 0 || !snapshot
-        ? undefined
-        : {
-            candidates,
-            snapshot,
-            summary: "Snapshot contains dialog/modal context plus likely close or dismiss controls; treat covered controls as potentially obstructed until the overlay state is resolved.",
-        };
-}
-function isSnapshotRefClick(data) {
-    return (isRecord(data) &&
-        typeof data.clicked === "string" &&
-        (data.clicked.startsWith("@") || data.clicked.startsWith("ref=")));
-}
-function stationaryRefClickUrl(options) {
-    if (options.command !== "click" || !isSnapshotRefClick(options.data)) {
-        return undefined;
-    }
-    const priorUrl = normalizeComparableUrl(options.priorTarget?.url);
-    const currentUrl = normalizeComparableUrl(options.navigationSummary?.url);
-    return currentUrl !== undefined && currentUrl !== "" && currentUrl === priorUrl
-        ? currentUrl
-        : undefined;
-}
-export async function collectOverlayBlockerDiagnostic(options) {
-    const currentUrl = stationaryRefClickUrl(options);
-    if (currentUrl === undefined) {
-        return undefined;
-    }
-    const snapshotData = await runSessionCommandData({
-        args: ["snapshot", "-i"],
-        cwd: options.cwd,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: options.signal,
-    });
-    const diagnostic = collectSnapshotOverlayBlockerDiagnostic(snapshotData);
-    return diagnostic
-        ? {
-            ...diagnostic,
-            summary: `Click completed but the page stayed on ${currentUrl}; a fresh snapshot contains likely overlay close/dismiss controls.`,
-        }
-        : undefined;
-}

package/dist/extensions/agent-browser/lib/orchestration/browser-run/prepare/network-page-filter.js

@@ -1,192 +0,0 @@
-import { isRecord } from "../../../parsing.js";
-import { buildAgentBrowserResultCategoryDetails } from "../../../results/categories.js";
-import { redactPresentationData } from "../../../results/presentation/diagnostics.js";
-import { redactInvocationArgs, redactSensitiveText } from "../../../runtime-redaction.js";
-import { buildSessionDetailFields, runSessionCommandData } from "../session-state.js";
-function parseNetworkRequestsPageFilterRequest(commandTokens) {
-    if (commandTokens[0] !== "network" || commandTokens[1] !== "requests") {
-        return undefined;
-    }
-    const cleanArgs = [];
-    let mode;
-    for (const token of commandTokens) {
-        if (token === "--current-page" || token === "--current-origin") {
-            mode = "origin";
-            continue;
-        }
-        if (token === "--current-url") {
-            mode = "url";
-            continue;
-        }
-        cleanArgs.push(token);
-    }
-    if (mode === undefined) {
-        return undefined;
-    }
-    return { cleanArgs, mode };
-}
-function extractCurrentUrl(data) {
-    if (typeof data === "string") {
-        return data;
-    }
-    if (!isRecord(data)) {
-        return undefined;
-    }
-    const candidates = [data.url, data.currentUrl, data.href, data.result];
-    for (const candidate of candidates) {
-        if (typeof candidate === "string" && candidate.length > 0) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function getRequestUrl(row) {
-    if (!isRecord(row)) {
-        return undefined;
-    }
-    const candidate = row.url ?? row.requestUrl ?? row.href;
-    return typeof candidate === "string" ? candidate : undefined;
-}
-function requestMatchesCurrentPage(row, currentUrl, mode) {
-    const requestUrl = getRequestUrl(row);
-    if (requestUrl === undefined || requestUrl === "") {
-        return false;
-    }
-    try {
-        const current = new URL(currentUrl);
-        const request = new URL(requestUrl, current);
-        if (mode === "origin") {
-            return current.origin === request.origin;
-        }
-        const currentComparable = `${current.origin}${current.pathname}`;
-        const requestComparable = `${request.origin}${request.pathname}`;
-        return requestComparable === currentComparable;
-    }
-    catch {
-        return mode === "url" ? requestUrl === currentUrl : requestUrl.startsWith(currentUrl);
-    }
-}
-function filterNetworkRequestsData(data, currentUrl, request) {
-    if (!isRecord(data)) {
-        return undefined;
-    }
-    const key = ["requests", "items", "entries"].find((name) => Array.isArray(data[name]));
-    if (key === undefined) {
-        return undefined;
-    }
-    const requestRows = data[key];
-    if (!Array.isArray(requestRows)) {
-        return undefined;
-    }
-    const rows = requestRows.filter((row) => requestMatchesCurrentPage(row, currentUrl, request.mode));
-    return {
-        data: { ...data, [key]: rows },
-        matchedRows: rows.length,
-        rows,
-        totalRows: requestRows.length,
-    };
-}
-function formatNetworkRequestRow(row) {
-    if (!isRecord(row)) {
-        return redactSensitiveText(formatNetworkValue(row));
-    }
-    const status = row.status ?? row.statusCode ?? row.responseStatus ?? "?";
-    const method = [row.method, row.requestMethod].find((value) => typeof value === "string") ?? "?";
-    const identifier = [row.id, row.requestId].find((value) => typeof value === "string");
-    const id = identifier === undefined ? "" : ` id=${identifier}`;
-    const url = getRequestUrl(row) ?? "(no url)";
-    return redactSensitiveText(`- ${formatNetworkValue(status)} ${method}${id} ${url}`);
-}
-function formatNetworkValue(value) {
-    switch (typeof value) {
-        case "string":
-        case "number":
-        case "bigint":
-        case "boolean":
-        case "undefined":
-        case "symbol":
-        case "function":
-            return String(value);
-        case "object":
-            if (value === null) {
-                return "null";
-            }
-            return Array.isArray(value)
-                ? value.map(formatNetworkArrayElement).join(",")
-                : Object.prototype.toString.call(value);
-    }
-}
-function formatNetworkArrayElement(value) {
-    return value === null || value === undefined ? "" : formatNetworkValue(value);
-}
-function formatFilteredNetworkText(options) {
-    const preview = options.rows.slice(0, 12).map(formatNetworkRequestRow);
-    const omitted = options.rows.length > preview.length
-        ? [`- …${options.rows.length - preview.length} more matching rows omitted`]
-        : [];
-    return [
-        redactSensitiveText(options.summary),
-        `Current page: ${redactSensitiveText(options.currentUrl)}`,
-        ...preview,
-        ...omitted,
-    ].join("\n");
-}
-export async function tryNetworkRequestsPageFilter(options) {
-    const request = parseNetworkRequestsPageFilterRequest(options.commandTokens);
-    if (!request || options.sessionName === undefined || options.sessionName === "") {
-        return undefined;
-    }
-    const currentUrl = extractCurrentUrl(await runSessionCommandData({
-        args: ["get", "url"],
-        cwd: options.cwd,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: options.signal,
-    }));
-    if (currentUrl === undefined || currentUrl === "") {
-        return undefined;
-    }
-    const networkData = await runSessionCommandData({
-        args: request.cleanArgs,
-        cwd: options.cwd,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: options.signal,
-    });
-    const filtered = filterNetworkRequestsData(networkData, currentUrl, request);
-    if (!filtered) {
-        return undefined;
-    }
-    const summary = `Network requests filtered to current ${request.mode === "origin" ? "origin" : "URL"}: ${filtered.matchedRows}/${filtered.totalRows} rows matched.`;
-    return {
-        content: [
-            {
-                type: "text",
-                text: formatFilteredNetworkText({ summary, currentUrl, rows: filtered.rows }),
-            },
-        ],
-        details: {
-            args: options.redactedArgs,
-            command: "network",
-            compatibilityWorkaround: options.compatibilityWorkaround,
-            data: redactPresentationData({ command: "network", subcommand: "requests" }, filtered.data),
-            effectiveArgs: options.effectiveArgs,
-            networkRequestsPageFilter: {
-                cleanArgs: redactInvocationArgs(request.cleanArgs),
-                currentUrl: redactSensitiveText(currentUrl),
-                matchedRows: filtered.matchedRows,
-                mode: request.mode,
-                totalRows: filtered.totalRows,
-            },
-            sessionMode: options.sessionMode,
-            ...buildAgentBrowserResultCategoryDetails({
-                args: options.effectiveArgs,
-                command: "network",
-                succeeded: true,
-            }),
-            ...buildSessionDetailFields(options.sessionName, options.usedImplicitSession, options.namespace, options.managedSessionRestoreDisabled()),
-            summary,
-        },
-        isError: false,
-    };
-}