pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -0,0 +1,290 @@
+import { isRecord } from "../../parsing.js";
+import { withOptionalSessionArgs } from "../../results/next-actions.js";
+import { redactSensitiveText } from "../../runtime-redaction.js";
+import { runSessionCommandData } from "./session-state.js";
+import { diagnosticResultRecord, rawNumberField, rawStringField } from "./diagnostic-values.js";
+function isScrollMeasurements(value) {
+    return (isRecord(value) &&
+        ["scrollX", "scrollY", "innerHeight", "innerWidth", "scrollHeight", "scrollWidth"].every((field) => typeof value[field] === "number"));
+}
+function parseScrollContainer(entry, index) {
+    if (!isRecord(entry)) {
+        return [];
+    }
+    const rawId = rawStringField(entry, "id");
+    const id = rawId !== undefined && rawId !== "" && /^\d+:[a-z][a-z0-9-]*(?:\[role=[a-z-]+\])?$/i.test(rawId)
+        ? rawId
+        : `sample-${index}`;
+    const scrollTop = rawNumberField(entry, "scrollTop");
+    const scrollLeft = rawNumberField(entry, "scrollLeft");
+    return scrollTop !== undefined && scrollLeft !== undefined ? [{ id, scrollLeft, scrollTop }] : [];
+}
+function extractScrollPositionSnapshot(data) {
+    const result = diagnosticResultRecord(data);
+    if (!result || !isScrollMeasurements(result)) {
+        return undefined;
+    }
+    const containers = Array.isArray(result.containers)
+        ? result.containers.flatMap(parseScrollContainer)
+        : [];
+    return {
+        containerCount: rawNumberField(result, "containerCount") ?? containers.length,
+        containers,
+        innerHeight: result.innerHeight,
+        innerWidth: result.innerWidth,
+        scrollHeight: result.scrollHeight,
+        scrollWidth: result.scrollWidth,
+        scrollX: result.scrollX,
+        scrollY: result.scrollY,
+    };
+}
+const SCROLL_POSITION_EVAL = `(() => {
+  const viewport = {
+    scrollX: window.scrollX,
+    scrollY: window.scrollY,
+    innerHeight: window.innerHeight,
+    innerWidth: window.innerWidth,
+    scrollHeight: Math.max(document.documentElement?.scrollHeight || 0, document.body?.scrollHeight || 0),
+    scrollWidth: Math.max(document.documentElement?.scrollWidth || 0, document.body?.scrollWidth || 0),
+  };
+  const describe = (element, index) => {
+    const role = element.getAttribute("role") || "";
+    const id = element.tagName.toLowerCase();
+    return { id: String(index) + ":" + id + (role ? "[role=" + role + "]" : ""), scrollTop: element.scrollTop, scrollLeft: element.scrollLeft, area: element.clientWidth * element.clientHeight };
+  };
+  const containers = Array.from(document.querySelectorAll("body *"))
+    .filter((element) => element instanceof HTMLElement && (element.scrollHeight > element.clientHeight + 1 || element.scrollWidth > element.clientWidth + 1))
+    .map(describe)
+    .sort((left, right) => right.area - left.area)
+    .slice(0, 10)
+    .map(({ area, ...entry }) => entry);
+  return { ...viewport, containerCount: containers.length, containers };
+})()`;
+export async function collectScrollPositionSnapshot(options) {
+    return extractScrollPositionSnapshot(await runSessionCommandData({
+        args: ["eval", "--stdin"],
+        cwd: options.cwd,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        signal: options.signal,
+        stdin: SCROLL_POSITION_EVAL,
+    }));
+}
+function sameScrollPositionSnapshot(left, right) {
+    return (left.scrollX === right.scrollX &&
+        left.scrollY === right.scrollY &&
+        left.scrollHeight === right.scrollHeight &&
+        left.scrollWidth === right.scrollWidth &&
+        left.containers.length === right.containers.length &&
+        left.containers.every((container, index) => {
+            const other = right.containers.at(index);
+            return (other !== undefined &&
+                other.id === container.id &&
+                other.scrollTop === container.scrollTop &&
+                other.scrollLeft === container.scrollLeft);
+        }));
+}
+export function buildUnsupportedScrollIntoViewRecovery(options) {
+    if (!["scrollintoview", "scrollinto"].includes(options.commandTokens.at(0) ?? "") ||
+        options.commandTokens.some((token) => token === "--help" || token === "-h")) {
+        return undefined;
+    }
+    const match = /^text=(.+)$/s.exec(options.commandTokens.at(1) ?? "");
+    if (!match) {
+        return undefined;
+    }
+    const text = redactSensitiveText(match[1]);
+    return {
+        error: "scrollintoview accepts a CSS selector, xpath=..., or a current @e… ref; text=... is not supported and can falsely report success without moving the page.",
+        nextActions: [
+            {
+                id: "scroll-semantic-text-target",
+                params: {
+                    args: withOptionalSessionArgs(options.sessionName, ["find", "text", text, "hover"]),
+                },
+                reason: "Use the upstream semantic text locator; hover resolves and scrolls the matched element into view.",
+                safety: "Hover may open a tooltip or menu. Use the snapshot/ref recovery instead when hover state could affect the workflow.",
+                tool: "agent_browser",
+            },
+            {
+                id: "refresh-refs-for-scroll-target",
+                params: { args: withOptionalSessionArgs(options.sessionName, ["snapshot", "-i"]) },
+                reason: "Capture a current element ref, then retry scrollintoview with that @e… ref.",
+                safety: "Read-only snapshot; choose the intended current ref before retrying the scroll.",
+                tool: "agent_browser",
+            },
+        ],
+    };
+}
+export function buildScrollNoopDiagnostic(before, after) {
+    if (!before || !after || !sameScrollPositionSnapshot(before, after)) {
+        return undefined;
+    }
+    return {
+        after,
+        before,
+        message: "Scroll reported success, but the viewport and sampled scrollable containers did not change position.",
+        reason: "no-observed-scroll-position-change",
+        recommendations: [
+            "Run snapshot -i or screenshot to confirm what is visible before choosing the next action.",
+            "On dashboards and panes with nested scrolling, use scrollintoview <@ref> for a visible target or target the actual scrollable region instead of repeating page scrolls.",
+        ],
+    };
+}
+export function buildScrollNoopNextActions(sessionName) {
+    return [
+        {
+            id: "inspect-after-noop-scroll",
+            params: { args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]) },
+            reason: "Refresh interactive refs and inspect whether the intended target is inside a nested scroll container.",
+            safety: "Do not assume repeated page scrolls will move dashboard panels or nested panes.",
+            tool: "agent_browser",
+        },
+        {
+            id: "verify-noop-scroll-visually",
+            params: { args: withOptionalSessionArgs(sessionName, ["screenshot"]) },
+            reason: "Capture the current viewport to verify whether the scroll actually changed visible content.",
+            safety: "Use screenshot evidence before concluding a dense dashboard did or did not move.",
+            tool: "agent_browser",
+        },
+    ];
+}
+export function formatScrollNoopDiagnosticText(diagnostic) {
+    if (!diagnostic) {
+        return undefined;
+    }
+    return [
+        "Scroll diagnostic: no observed scroll movement.",
+        `Reason: ${diagnostic.message}`,
+        `Sampled scrollable containers: ${diagnostic.after.containers.length}/${diagnostic.after.containerCount}.`,
+        ...diagnostic.recommendations.map((recommendation) => `- ${recommendation}`),
+    ].join("\n");
+}
+const COMBOBOX_FOCUS_EVAL = `(() => {
+  const isVisible = (element) => {
+    if (!(element instanceof HTMLElement)) return false;
+    const style = window.getComputedStyle(element);
+    if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0) return false;
+    return element.getClientRects().length > 0;
+  };
+  const active = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+  const role = active?.getAttribute("role") || undefined;
+  const hasPopup = active?.getAttribute("aria-haspopup") || undefined;
+  const expanded = active?.getAttribute("aria-expanded") || undefined;
+  const tagName = active?.tagName.toLowerCase();
+  const name = (active?.getAttribute("aria-label") || active?.getAttribute("placeholder") || active?.getAttribute("title") || active?.textContent || "").trim().slice(0, 80) || undefined;
+  const visibleListboxCount = Array.from(document.querySelectorAll('[role="listbox"], [role="menu"]')).filter(isVisible).length;
+  const visibleOptionCount = Array.from(document.querySelectorAll('[role="option"], option, [role="menuitem"]')).filter(isVisible).length;
+  const comboboxLike = role === "combobox" || hasPopup === "listbox" || hasPopup === "menu" || tagName === "select" || active?.getAttribute("aria-autocomplete") !== null;
+  return { activeElement: active ? { expanded, hasPopup, name, role, tagName } : undefined, comboboxLike, visibleListboxCount, visibleOptionCount };
+})()`;
+function comboboxActiveElement(result, expanded) {
+    const name = rawStringField(result, "name");
+    return {
+        expanded,
+        hasPopup: rawStringField(result, "hasPopup"),
+        name: name === undefined ? undefined : redactSensitiveText(name),
+        role: rawStringField(result, "role"),
+        tagName: rawStringField(result, "tagName"),
+    };
+}
+function extractComboboxFocusDiagnostic(data) {
+    const result = diagnosticResultRecord(data);
+    if (!result || result.comboboxLike !== true || !isRecord(result.activeElement)) {
+        return undefined;
+    }
+    const visibleListboxCount = rawNumberField(result, "visibleListboxCount") ?? 0;
+    const visibleOptionCount = rawNumberField(result, "visibleOptionCount") ?? 0;
+    const expanded = rawStringField(result.activeElement, "expanded");
+    if ((expanded !== "false" && expanded !== "true") ||
+        visibleListboxCount > 0 ||
+        visibleOptionCount > 0) {
+        return undefined;
+    }
+    return {
+        activeElement: comboboxActiveElement(result.activeElement, expanded),
+        message: "A combobox-like control is focused, but no listbox or option elements are visibly open.",
+        reason: "focused-combobox-without-visible-options",
+        recommendations: [
+            "Run snapshot -i to inspect whether options appeared under a different role or portal.",
+            "Try ArrowDown or Enter to open the option list before selecting, or use select/visible option refs when available.",
+        ],
+        visibleListboxCount,
+        visibleOptionCount,
+    };
+}
+function isComboboxFocusDiagnosticCommand(command, commandTokens) {
+    if (!commandTokens.some((token) => /^(?:combobox|listbox)$/i.test(token))) {
+        return false;
+    }
+    if (command === "click" || command === "fill") {
+        return true;
+    }
+    return command === "find" && commandTokens.some((token) => ["click", "fill"].includes(token));
+}
+function getCompiledSemanticActionRoleValue(compiled) {
+    if (compiled.locator !== "role") {
+        return undefined;
+    }
+    const findIndex = compiled.args.indexOf("find");
+    if (findIndex < 0 || compiled.args[findIndex + 1] !== "role") {
+        return undefined;
+    }
+    return compiled.args[findIndex + 2];
+}
+function isComboboxFocusDiagnosticSemanticAction(compiled) {
+    return (compiled !== undefined &&
+        ["click", "fill"].includes(compiled.action) &&
+        /^(?:combobox|listbox)$/i.test(getCompiledSemanticActionRoleValue(compiled) ?? ""));
+}
+export async function collectComboboxFocusDiagnostic(options) {
+    if (!isComboboxFocusDiagnosticCommand(options.command, options.commandTokens) &&
+        !isComboboxFocusDiagnosticSemanticAction(options.semanticAction)) {
+        return undefined;
+    }
+    return extractComboboxFocusDiagnostic(await runSessionCommandData({
+        args: ["eval", "--stdin"],
+        cwd: options.cwd,
+        namespace: options.namespace,
+        sessionName: options.sessionName,
+        signal: options.signal,
+        stdin: COMBOBOX_FOCUS_EVAL,
+    }));
+}
+export function buildComboboxFocusNextActions(sessionName) {
+    return [
+        {
+            id: "inspect-focused-combobox",
+            params: { args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]) },
+            reason: "Inspect the focused combobox and any portal/listbox refs before choosing an option.",
+            safety: "Prefer visible option refs or select when a native/selectable option list is exposed.",
+            tool: "agent_browser",
+        },
+        {
+            id: "try-open-combobox-with-arrow",
+            params: { args: withOptionalSessionArgs(sessionName, ["press", "ArrowDown"]) },
+            reason: "Many searchable comboboxes open their option list with ArrowDown after focus.",
+            safety: "Use only when the focused combobox is still the intended control, then re-snapshot before selecting.",
+            tool: "agent_browser",
+        },
+        {
+            id: "try-open-combobox-with-enter",
+            params: { args: withOptionalSessionArgs(sessionName, ["press", "Enter"]) },
+            reason: "Some comboboxes open or confirm their option list with Enter after focus.",
+            safety: "Enter may select a highlighted/default option; prefer ArrowDown first unless Enter is the app's expected opener.",
+            tool: "agent_browser",
+        },
+    ];
+}
+export function formatComboboxFocusDiagnosticText(diagnostic) {
+    if (!diagnostic) {
+        return undefined;
+    }
+    const name = diagnostic.activeElement.name;
+    const label = name !== undefined && name !== "" ? ` (${name})` : "";
+    return [
+        `Combobox diagnostic: focused combobox did not expose visible options${label}.`,
+        `Reason: ${diagnostic.message}`,
+        ...diagnostic.recommendations.map((recommendation) => `- ${recommendation}`),
+    ].join("\n");
+}

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

@@ -0,0 +1,167 @@
+import { rm } from "node:fs/promises";
+import { acquireManagedSessionPolicyLock, } from "../../managed-session-policy-lock.js";
+import { pruneOwnedManagedSessionRestoreSnapshots, } from "../../managed-session-restore.js";
+import { isManagedSessionRestoreKey } from "../../managed-session-storage.js";
+import { isRecord } from "../../parsing.js";
+import { withAgentBrowserProcessEnvironment } from "../../process-environment.js";
+import { runAgentBrowserProcess } from "../../process.js";
+import { getAgentBrowserErrorText, parseAgentBrowserEnvelope } from "../../results/envelope.js";
+import { detectConfirmationRequired } from "../../results/confirmation.js";
+import { stringifyUnknown } from "../../results/text.js";
+import { redactInvocationArgs } from "../../runtime-redaction.js";
+import { getHeadedManagedAutosaveEnv, inspectManagedSessionDaemon, } from "./managed-session-daemon-inspection.js";
+function getCloseArgs(options) {
+    return [
+        ...(options.namespace !== undefined ? ["--namespace", options.namespace] : []),
+        "--session",
+        options.sessionName,
+        "close",
+    ];
+}
+async function inspectCloseRestoreKey(options, signal) {
+    const daemon = await inspectManagedSessionDaemon({
+        cwd: options.cwd,
+        headedManagedAutosaveInterval: options.headedManagedAutosaveInterval,
+        namespace: options.namespace,
+        preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
+        sessionName: options.sessionName,
+        signal,
+        timeoutMs: Math.min(options.timeoutMs, 2_000),
+    });
+    if (daemon.status === "active") {
+        options.restoreState.recordDaemonRestoreKey(options.sessionName, options.namespace, daemon.restoreKey);
+    }
+    const daemonRestoreKey = options.restoreState.getDaemonRestoreKey(options.sessionName, options.namespace);
+    return !options.restoreState.isDisabled(options.sessionName, options.namespace) &&
+        isManagedSessionRestoreKey(daemonRestoreKey)
+        ? daemonRestoreKey
+        : null;
+}
+function confirmedClosedData(processResult, envelope) {
+    return !processResult.aborted &&
+        !processResult.spawnError &&
+        processResult.exitCode === 0 &&
+        envelope?.success === true &&
+        isRecord(envelope.data) &&
+        envelope.data.closed === true
+        ? envelope.data
+        : undefined;
+}
+async function finishManagedClose(options, processResult, ownedRestoreKey) {
+    const parsed = await parseAgentBrowserEnvelope({
+        stdout: processResult.stdout,
+        stdoutPath: processResult.stdoutSpillPath,
+    });
+    const closedData = confirmedClosedData(processResult, parsed.envelope);
+    if (closedData) {
+        options.restoreState.clear(options.sessionName, options.namespace);
+        pruneOwnedManagedSessionRestoreSnapshots({
+            cwd: options.cwd,
+            namespace: options.namespace,
+            restoreKey: ownedRestoreKey,
+            statePath: typeof closedData.statePath === "string" ? closedData.statePath : undefined,
+        });
+    }
+    const pending = detectConfirmationRequired(parsed.envelope?.data);
+    if (pending) {
+        return `Native close requires confirmation (${pending.id}); the session remains wrapper-owned.`;
+    }
+    return getAgentBrowserErrorText({
+        aborted: processResult.aborted,
+        command: "close",
+        effectiveArgs: redactInvocationArgs(getCloseArgs(options)),
+        envelope: parsed.envelope,
+        exitCode: processResult.exitCode,
+        parseError: parsed.parseError,
+        plainTextInspection: false,
+        spawnError: processResult.spawnError,
+        stderr: processResult.stderr,
+        timedOut: processResult.timedOut,
+        timeoutMs: processResult.timeoutMs,
+    });
+}
+async function closeUnderPolicy(options, lifecycle) {
+    lifecycle.enterPhase("daemon inspection");
+    const ownedRestoreKey = await inspectCloseRestoreKey(options, lifecycle.signal);
+    lifecycle.enterPhase("native close");
+    const processResult = await runAgentBrowserProcess({
+        args: getCloseArgs(options),
+        cwd: options.cwd,
+        env: {
+            AGENT_BROWSER_JSON: "1",
+            ...getHeadedManagedAutosaveEnv(options.headedManagedAutosaveInterval),
+        },
+        managedSessionRestoreState: options.restoreState,
+        ownedManagedSession: true,
+        preserveAttachedBrowserSession: options.preserveAttachedBrowserSession,
+        signal: lifecycle.signal,
+    });
+    lifecycle.clearTimer();
+    try {
+        return await finishManagedClose(options, processResult, ownedRestoreKey);
+    }
+    finally {
+        if (processResult.stdoutSpillPath !== undefined && processResult.stdoutSpillPath !== "") {
+            await rm(processResult.stdoutSpillPath, { force: true }).catch(() => {
+                // A spill removal failure must not replace the native close result.
+            });
+        }
+    }
+}
+async function closeWithDeadline(options) {
+    const controller = new AbortController();
+    let phase = "policy coordination";
+    let phaseStartedAt = Date.now();
+    let timeoutError;
+    const timer = setTimeout(() => {
+        timeoutError = `Managed-session cleanup timed out after ${options.timeoutMs} ms during ${phase} (${Date.now() - phaseStartedAt} ms in this phase).`;
+        controller.abort();
+    }, options.timeoutMs);
+    const lifecycle = {
+        signal: controller.signal,
+        enterPhase: (nextPhase) => {
+            phase = nextPhase;
+            phaseStartedAt = Date.now();
+        },
+        clearTimer: () => {
+            clearTimeout(timer);
+        },
+    };
+    let policyLock;
+    try {
+        policyLock =
+            options.policyLock ??
+                (await acquireManagedSessionPolicyLock({
+                    namespace: options.namespace,
+                    sessionName: options.sessionName,
+                    signal: controller.signal,
+                    timeoutMs: Math.min(options.timeoutMs, 1_000),
+                }));
+        if (!policyLock) {
+            return (timeoutError ??
+                "Managed-session policy coordination is unavailable or busy; cleanup did not run. Retry after the current operation finishes or repair the private policy-lock directory.");
+        }
+        try {
+            const closeError = await closeUnderPolicy(options, lifecycle);
+            // The deadline callback can update timeoutError while any close phase is suspended.
+            return timeoutError ?? closeError;
+        }
+        catch (error) {
+            return timeoutError ?? (error instanceof Error ? error.message : stringifyUnknown(error));
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        if (options.policyLock === undefined && policyLock) {
+            await policyLock.release();
+        }
+    }
+}
+export function closeManagedSession(options) {
+    return withAgentBrowserProcessEnvironment({
+        AGENT_BROWSER_CONFIRM_ACTIONS: options.confirmActions,
+        ...(options.socketDir !== undefined && options.socketDir !== ""
+            ? { PI_AGENT_BROWSER_SOCKET_DIR: options.socketDir }
+            : {}),
+    }, () => closeWithDeadline(options));
+}

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

@@ -0,0 +1,108 @@
+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.
+            });
+        }
+    }
+}