pi-agent-browser-native 0.2.72 → 0.2.75

package/dist/extensions/agent-browser/lib/managed-session-storage.js

@@ -0,0 +1,299 @@
+/**
+ * Purpose: Resolve and secure the filesystem identity used by automatic managed-session restore.
+ * Responsibilities: Bind restore keys to one Git checkout generation, validate trusted HOME ancestry, and prepare owner-only upstream state directories.
+ * Scope: Filesystem policy only; argv/session ownership and snapshot retention live in sibling modules.
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { linkSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, parse, resolve, win32 } from "node:path";
+import { canonicalizeAgentBrowserNamespace } from "./argv-grammar.js";
+export { isManagedSessionRestoreKey } from "./managed-session-capabilities.js";
+const MANAGED_SESSION_NAME_PREFIX = "piab-r2-";
+const MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH = 32;
+const PROJECT_GENERATION_MARKER_NAME = "pi-agent-browser-project-generation-v1.json";
+const PROJECT_GENERATION_MARKER_MAX_BYTES = 1_024;
+const projectGenerationCache = new Map();
+function isAbsoluteHome(path, platform) {
+    return platform === "win32" ? win32.isAbsolute(path) : isAbsolute(path);
+}
+function currentUid() {
+    return typeof process.getuid === "function" ? process.getuid() : undefined;
+}
+function isTrustedPosixDirectory(path, requireCurrentOwner) {
+    const uid = currentUid();
+    if (uid === undefined)
+        return false;
+    const root = parse(path).root;
+    let cursor = root;
+    for (const component of path.slice(root.length).split("/").filter(Boolean)) {
+        cursor = join(cursor, component);
+        let entry;
+        try {
+            entry = lstatSync(cursor);
+        }
+        catch {
+            return false;
+        }
+        if (entry.isSymbolicLink() || !entry.isDirectory())
+            return false;
+        if (entry.uid !== 0 && entry.uid !== uid)
+            return false;
+        const writableByOthers = (entry.mode & 0o022) !== 0;
+        const rootOwnedStickyDirectory = entry.uid === 0 && (entry.mode & 0o1000) !== 0;
+        if (writableByOthers && !rootOwnedStickyDirectory)
+            return false;
+    }
+    try {
+        const leaf = lstatSync(path);
+        return !requireCurrentOwner || leaf.uid === uid;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveManagedSessionRestoreHome(parentEnv, platform = process.platform) {
+    const configuredHome = platform === "win32" ? parentEnv.USERPROFILE : parentEnv.HOME;
+    const candidate = configuredHome ?? homedir();
+    if (!candidate || candidate.trim() !== candidate || !isAbsoluteHome(candidate, platform))
+        return undefined;
+    if (platform === "win32")
+        return candidate;
+    try {
+        const canonical = realpathSync(candidate);
+        return isTrustedPosixDirectory(canonical, true) ? canonical : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function ensureOwnerOnlyDirectory(path, platform = process.platform) {
+    try {
+        try {
+            mkdirSync(path, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                return false;
+        }
+        const entry = lstatSync(path);
+        if (entry.isSymbolicLink() || !entry.isDirectory())
+            return false;
+        if (platform === "win32")
+            return true;
+        const uid = currentUid();
+        return uid !== undefined && entry.uid === uid && (entry.mode & 0o077) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function directoryContainsSymlink(path) {
+    try {
+        return readdirSync(path, { withFileTypes: true }).some((entry) => entry.isSymbolicLink());
+    }
+    catch {
+        return true;
+    }
+}
+function resolveGitCheckout(cwd, platform) {
+    let directory = cwd;
+    while (true) {
+        const dotGit = join(directory, ".git");
+        try {
+            const entry = lstatSync(dotGit);
+            if (entry.isDirectory() && !entry.isSymbolicLink())
+                return { gitDirectory: realpathSync(dotGit), worktreeDirectory: realpathSync(directory) };
+            if (!entry.isFile() || entry.isSymbolicLink() || entry.size > PROJECT_GENERATION_MARKER_MAX_BYTES)
+                return undefined;
+            if (platform !== "win32") {
+                const uid = currentUid();
+                if (uid === undefined || entry.uid !== uid || (entry.mode & 0o022) !== 0)
+                    return undefined;
+            }
+            const match = /^gitdir:\s*(.+)\s*$/i.exec(readFileSync(dotGit, "utf8"));
+            if (!match?.[1])
+                return undefined;
+            return { gitDirectory: realpathSync(resolve(directory, match[1])), worktreeDirectory: realpathSync(directory) };
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return undefined;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+function readProjectGenerationMarker(path, platform) {
+    try {
+        const entry = lstatSync(path);
+        if (entry.isSymbolicLink() || !entry.isFile() || entry.size > PROJECT_GENERATION_MARKER_MAX_BYTES)
+            return undefined;
+        if (platform !== "win32") {
+            const uid = currentUid();
+            if (uid === undefined || entry.uid !== uid || (entry.mode & 0o177) !== 0)
+                return undefined;
+        }
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parsed.version === 1 && typeof parsed.id === "string" && /^[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}$/i.test(parsed.id) ? parsed.id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getDirectoryFilesystemIdentity(path) {
+    try {
+        const entry = statSync(path, { bigint: true });
+        return entry.isDirectory() && entry.dev > 0n && entry.ino > 0n && entry.birthtimeNs > 0n
+            ? `${entry.dev}:${entry.ino}:${entry.birthtimeNs}`
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveManagedSessionRestoreProjectCheckout(cwd, platform) {
+    let canonicalCwd;
+    try {
+        canonicalCwd = realpathSync(cwd);
+    }
+    catch {
+        return undefined;
+    }
+    if (platform !== "win32" && !isTrustedPosixDirectory(canonicalCwd, false))
+        return undefined;
+    const checkout = resolveGitCheckout(canonicalCwd, platform);
+    if (!checkout)
+        return undefined;
+    if (platform !== "win32" && (!isTrustedPosixDirectory(checkout.worktreeDirectory, true)
+        || !isTrustedPosixDirectory(checkout.gitDirectory, true)))
+        return undefined;
+    return { canonicalCwd, ...checkout };
+}
+export function resolveManagedSessionRestoreCheckoutRoot(cwd, platform = process.platform) {
+    return resolveManagedSessionRestoreProjectCheckout(cwd, platform)?.worktreeDirectory;
+}
+function resolveProjectGenerationIdentity(cwd, platform = process.platform) {
+    const checkout = resolveManagedSessionRestoreProjectCheckout(cwd, platform);
+    if (!checkout)
+        return undefined;
+    const { canonicalCwd } = checkout;
+    const gitFilesystemIdentity = getDirectoryFilesystemIdentity(checkout.gitDirectory);
+    const worktreeFilesystemIdentity = getDirectoryFilesystemIdentity(checkout.worktreeDirectory);
+    if (!gitFilesystemIdentity || !worktreeFilesystemIdentity)
+        return undefined;
+    const markerPath = join(checkout.gitDirectory, PROJECT_GENERATION_MARKER_NAME);
+    let marker = readProjectGenerationMarker(markerPath, platform);
+    const cached = projectGenerationCache.get(canonicalCwd);
+    if (cached
+        && cached.gitDirectory === checkout.gitDirectory
+        && cached.worktreeDirectory === checkout.worktreeDirectory
+        && cached.gitFilesystemIdentity === gitFilesystemIdentity
+        && cached.worktreeFilesystemIdentity === worktreeFilesystemIdentity
+        && cached.marker === marker)
+        return cached.identity;
+    projectGenerationCache.delete(canonicalCwd);
+    try {
+        if (!marker) {
+            const candidatePath = `${markerPath}.candidate-${process.pid}-${randomUUID()}`;
+            try {
+                writeFileSync(candidatePath, JSON.stringify({ id: randomUUID(), version: 1 }), { encoding: "utf8", flag: "wx", mode: 0o600 });
+                try {
+                    linkSync(candidatePath, markerPath);
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST")
+                        return undefined;
+                }
+            }
+            finally {
+                try {
+                    unlinkSync(candidatePath);
+                }
+                catch { }
+            }
+            marker = readProjectGenerationMarker(markerPath, platform);
+        }
+        if (!marker)
+            return undefined;
+        const identity = `${platform}:${worktreeFilesystemIdentity}:${gitFilesystemIdentity}:${marker}`;
+        projectGenerationCache.set(canonicalCwd, {
+            gitDirectory: checkout.gitDirectory,
+            gitFilesystemIdentity,
+            identity,
+            marker,
+            worktreeDirectory: checkout.worktreeDirectory,
+            worktreeFilesystemIdentity,
+        });
+        return identity;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hasManagedSessionRestoreProjectIdentity(cwd) {
+    return resolveProjectGenerationIdentity(cwd) !== undefined;
+}
+/** Stable for one checkout generation; deliberately changes when a path is replaced by another checkout. */
+export function createManagedSessionRestoreKey(cwd) {
+    let canonicalCwd = resolve(cwd);
+    try {
+        canonicalCwd = realpathSync(canonicalCwd);
+    }
+    catch { }
+    const identity = resolveProjectGenerationIdentity(canonicalCwd);
+    const material = identity ?? `unavailable:${canonicalCwd}`;
+    const digest = createHash("sha256").update(`restore-v2:${material}`).digest("hex").slice(0, MANAGED_SESSION_RESTORE_KEY_HASH_LENGTH);
+    return `${MANAGED_SESSION_NAME_PREFIX}${digest}`;
+}
+function hasValidEncryptionKey(parentEnv) {
+    const value = parentEnv.AGENT_BROWSER_ENCRYPTION_KEY;
+    return typeof value === "string" && /^[a-f\d]{64}$/i.test(value);
+}
+export function getManagedRestoreSessionsDirectory(home, namespace) {
+    const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
+    return canonicalNamespace
+        ? join(home, ".agent-browser", "namespaces", canonicalNamespace, "state", "sessions")
+        : join(home, ".agent-browser", "sessions");
+}
+/** Require the upstream 256-bit key format and secure every directory that can receive restore snapshots. */
+export function ensureManagedSessionRestoreStorageIsSecure(parentEnv = process.env, platform = process.platform, namespace) {
+    const encryptionKey = parentEnv.AGENT_BROWSER_ENCRYPTION_KEY;
+    if (encryptionKey !== undefined && !hasValidEncryptionKey(parentEnv))
+        return false;
+    if (platform === "win32")
+        return hasValidEncryptionKey(parentEnv);
+    const home = resolveManagedSessionRestoreHome(parentEnv, platform);
+    if (!home)
+        return false;
+    const root = join(home, ".agent-browser");
+    if (!ensureOwnerOnlyDirectory(root, platform))
+        return false;
+    const canonicalNamespace = canonicalizeAgentBrowserNamespace(namespace);
+    const stateComponents = canonicalNamespace
+        ? ["namespaces", canonicalNamespace, "state", "sessions"]
+        : ["sessions"];
+    let path = root;
+    for (const component of stateComponents) {
+        path = join(path, component);
+        if (!ensureOwnerOnlyDirectory(path, platform))
+            return false;
+    }
+    if (directoryContainsSymlink(path))
+        return false;
+    const temporaryDirectory = join(path, ".tmp");
+    return ensureOwnerOnlyDirectory(temporaryDirectory, platform) && !directoryContainsSymlink(temporaryDirectory);
+}
+export function getManagedSessionRestoreProtectedStorageEnv(restoreEnabled, parentEnv, platform = process.platform) {
+    if (!restoreEnabled)
+        return {};
+    const home = resolveManagedSessionRestoreHome(parentEnv, platform);
+    if (!home)
+        return {};
+    return {
+        AGENT_BROWSER_ENCRYPTION_KEY: parentEnv.AGENT_BROWSER_ENCRYPTION_KEY,
+        ...(platform === "win32" ? { USERPROFILE: home } : { HOME: home }),
+    };
+}

package/dist/extensions/agent-browser/lib/orchestration/batch-stdin.js

@@ -1,3 +1,38 @@
+// Mirror upstream commands::shell_words_split so policy inspection sees the same argv.
+export function parseBatchCommandArgument(command) {
+    const tokens = [];
+    let token = "";
+    let inDoubleQuote = false;
+    let inSingleQuote = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && !inSingleQuote) {
+            const next = command[index + 1];
+            if (next !== undefined) {
+                token += next;
+                index += 1;
+            }
+        }
+        else if (character === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+        else if (character === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        }
+        else if (character === " " && !inDoubleQuote && !inSingleQuote) {
+            if (token !== "") {
+                tokens.push(token);
+                token = "";
+            }
+        }
+        else {
+            token += character;
+        }
+    }
+    if (token !== "")
+        tokens.push(token);
+    return tokens.length > 0 ? { step: tokens } : { error: "batch command is empty" };
+}
 function validateUserBatchStep(step, index) {
     if (!Array.isArray(step)) {
         return {

package/dist/extensions/agent-browser/lib/orchestration/browser-run/artifact-paths.js

@@ -1,4 +1,6 @@
 import { extname, isAbsolute } from "node:path";
+import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS } from "../../argv-grammar.js";
+const SCREENSHOT_BOOLEAN_FLAGS = new Set(["--annotate", "--full", "-f"]);
 const SCREENSHOT_VALUE_FLAGS = new Set(["--screenshot-dir", "--screenshot-format", "--screenshot-quality"]);
 const SCREENSHOT_IMAGE_EXTENSIONS = new Set([".jpeg", ".jpg", ".png", ".webp"]);
 function isImagePathToken(token) {
@@ -20,10 +22,15 @@ export function getScreenshotPathTokenIndex(commandTokens) {
         }
         if (token.startsWith("-")) {
             const normalizedToken = token.split("=", 1)[0] ?? token;
-            if (SCREENSHOT_VALUE_FLAGS.has(normalizedToken) && !token.includes("=")) {
+            if ((SCREENSHOT_VALUE_FLAGS.has(normalizedToken) || VALUE_FLAGS.has(normalizedToken)) && !token.includes("=")) {
                 index += 1;
+                continue;
+            }
+            if (SCREENSHOT_BOOLEAN_FLAGS.has(normalizedToken) || GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(normalizedToken)) {
+                if (["true", "false"].includes(commandTokens[index + 1] ?? ""))
+                    index += 1;
+                continue;
             }
-            continue;
         }
         positionalIndices.push(index);
     }

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

@@ -10,6 +10,7 @@ import { buildVisibleRefFallbackDiagnosticFromSnapshot, getVisibleRefFallbackTar
 import { extractRefSnapshotFromData, normalizeComparableUrl } from "../../session-page-state.js";
 import { redactInvocationArgs, redactSensitiveText } from "../../runtime.js";
 import { isRecord } from "../../parsing.js";
+import { getManagedSessionStateAccessValidationError, isFileUrl } from "../../managed-session-state-policy.js";
 import { extractBatchResultCommand, extractNavigationSummaryFromData, extractStringResultField, findElectronLaunchRecordForSession, runSessionCommandData, } from "./session-state.js";
 import { parseValidBatchStepEntries } from "../batch-stdin.js";
 import { getScreenshotPathTokenIndex } from "./artifact-paths.js";
@@ -19,17 +20,12 @@ export function sleepMs(ms) {
 }
 export async function collectNavigationSummary(options) {
     const url = extractStringResultField(await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal }), "url");
+    if (!url || !/^[a-z][a-z0-9+.-]*:/i.test(url))
+        return undefined;
+    if (isFileUrl(url))
+        return { url };
     const title = extractStringResultField(await runSessionCommandData({ args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal }), "title");
-    if (url && /^[a-z][a-z0-9+.-]*:/i.test(url))
-        return { title, url };
-    return extractNavigationSummaryFromData(await runSessionCommandData({
-        args: ["eval", "--stdin"],
-        cwd: options.cwd,
-        namespace: options.namespace,
-        sessionName: options.sessionName,
-        signal: options.signal,
-        stdin: `({ title: document.title, url: location.href })`,
-    }));
+    return { title, url };
 }
 function extractScrollPositionSnapshot(data) {
     const result = isRecord(data) && isRecord(data.result) ? data.result : data;
@@ -507,7 +503,7 @@ export function formatArtifactCleanupGuidanceText(guidance) {
 }
 async function collectManagedSessionCommandData(options) {
     try {
-        return { data: await runSessionCommandData(options) };
+        return { data: await runSessionCommandData({ ...options, pinNamespace: true }) };
     }
     catch (error) {
         return { error: error instanceof Error ? error.message : String(error) };
@@ -528,14 +524,16 @@ async function collectElectronManagedSessionUrl(options) {
 export async function collectElectronManagedSessionTarget(options) {
     if (!options.sessionName)
         return undefined;
-    const [titleResult, urlResult] = await Promise.all([
-        collectManagedSessionCommandData({ args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, timeoutMs: options.timeoutMs }),
-        collectManagedSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, timeoutMs: options.timeoutMs }),
-    ]);
-    const title = boundElectronProbeString(extractStringResultField(titleResult.data, "result") ?? extractStringResultField(titleResult.data, "title"), 160);
+    const urlResult = await collectManagedSessionCommandData({ allowManagedSessionTarget: options.allowManagedSessionTarget, args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, timeoutMs: options.timeoutMs });
     const url = boundElectronProbeString(extractStringResultField(urlResult.data, "result") ?? extractStringResultField(urlResult.data, "url"), 300);
-    const errors = [titleResult.error, urlResult.error].filter((value) => value !== undefined);
-    return { sessionName: options.sessionName, title, url, ...(errors.length > 0 ? { error: errors.join("; ") } : {}) };
+    if (urlResult.error || !url)
+        return { error: urlResult.error ?? "get url returned no active page URL.", sessionName: options.sessionName };
+    const fileAccessError = getManagedSessionStateAccessValidationError({ args: ["get", "title"], currentPageUrl: url, cwd: options.cwd });
+    if (fileAccessError)
+        return { error: fileAccessError, sessionName: options.sessionName, url };
+    const titleResult = await collectManagedSessionCommandData({ allowManagedSessionTarget: options.allowManagedSessionTarget, args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, timeoutMs: options.timeoutMs });
+    const title = boundElectronProbeString(extractStringResultField(titleResult.data, "result") ?? extractStringResultField(titleResult.data, "title"), 160);
+    return { sessionName: options.sessionName, title, url, ...(titleResult.error ? { error: titleResult.error } : {}) };
 }
 export async function collectQaAttachedTarget(options) {
     if (!options.sessionName)
@@ -673,16 +671,33 @@ export async function collectVisibleRefFallbackDiagnostic(options) {
 export async function collectElectronHandoff(options) {
     if (options.handoff === "connect")
         return { handoff: "connect" };
-    const tabs = await runSessionCommandData({ args: ["tab", "list"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal });
+    if (options.signal?.aborted)
+        throw new Error("Electron handoff was aborted.");
+    const urlData = await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, throwOnFailure: true });
+    if (options.signal?.aborted)
+        throw new Error("Electron handoff was aborted.");
+    const url = extractStringResultField(urlData, "result") ?? extractStringResultField(urlData, "url");
+    if (!url)
+        throw new Error("Electron handoff get url returned no active page URL.");
+    const fileAccessError = getManagedSessionStateAccessValidationError({ args: ["snapshot", "-i"], currentPageUrl: url, cwd: options.cwd });
+    if (fileAccessError)
+        return { error: fileAccessError, failureCategory: "validation-error", handoff: options.handoff };
+    const tabs = await runSessionCommandData({ args: ["tab", "list"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, throwOnFailure: true });
+    if (options.signal?.aborted)
+        throw new Error("Electron handoff was aborted.");
     if (options.handoff === "tabs")
         return { handoff: "tabs", tabs };
-    let snapshot = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal });
+    let snapshot = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, throwOnFailure: true });
     let refSnapshot = extractRefSnapshotFromData(snapshot);
     let snapshotRetryCount = 0;
     while ((!refSnapshot || refSnapshot.refIds.length === 0) && snapshotRetryCount < 2) {
+        if (options.signal?.aborted)
+            throw new Error("Electron handoff was aborted.");
         snapshotRetryCount += 1;
         await sleepMs(250);
-        snapshot = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal });
+        if (options.signal?.aborted)
+            throw new Error("Electron handoff was aborted.");
+        snapshot = await runSessionCommandData({ args: ["snapshot", "-i"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName, signal: options.signal, throwOnFailure: true });
         refSnapshot = extractRefSnapshotFromData(snapshot);
     }
     return { handoff: "snapshot", refSnapshot, snapshot, ...(snapshotRetryCount > 0 ? { snapshotRetryCount } : {}), tabs };
@@ -857,8 +872,11 @@ function buildTimeoutProgressSteps(options) {
 export async function collectTimeoutPartialProgress(options) {
     const rawSteps = getTimeoutProgressSteps(options.compiledJob, options.command, options.stdin);
     const artifacts = await collectTimeoutArtifactEvidence(options.cwd, rawSteps);
-    const [urlData, titleData] = await Promise.all([runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName }), runSessionCommandData({ args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName })]);
+    const urlData = await runSessionCommandData({ args: ["get", "url"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName });
     const recoveredUrl = extractStringResultField(urlData, "result") ?? extractStringResultField(urlData, "url");
+    const titleData = recoveredUrl && !isFileUrl(recoveredUrl)
+        ? await runSessionCommandData({ args: ["get", "title"], cwd: options.cwd, namespace: options.namespace, sessionName: options.sessionName })
+        : undefined;
     const title = extractStringResultField(titleData, "result") ?? extractStringResultField(titleData, "title");
     const plannedUrl = recoveredUrl ? undefined : getPlannedCurrentPageUrl(rawSteps);
     const url = recoveredUrl ?? plannedUrl;

package/dist/extensions/agent-browser/lib/orchestration/browser-run/final-result.js

@@ -6,7 +6,8 @@ import { AgentBrowserNextActionCollector, alignPageChangeSummaryNextActionIds, a
 import { buildConnectedSessionNextActions, buildNoActivePageNextActions, buildSessionAwareStaleRefNextActions, buildSessionTabRecoveryNextActions, } from "../../results/recovery-next-actions.js";
 import { buildRichInputRecoveryDiagnostic, buildRichInputRecoveryNextActions, buildVisibleRefFallbackNextActions, formatRichInputRecoveryText, formatVisibleRefFallbackText, sanitizeVisibleRefFallbackDiagnostic, } from "../../results/selector-recovery.js";
 import { buildNoActivePageRefSnapshotInvalidation, isNoActivePageSnapshotFailure, } from "../../session-page-state.js";
-import { extractExplicitSessionName, redactInvocationArgs, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
+import { extractExplicitSessionName } from "../../argv-grammar.js";
+import { redactInvocationArgs, redactSensitiveText, redactSensitiveValue } from "../../runtime.js";
 import { isRecord } from "../../parsing.js";
 import { buildClickDispatchNextActions, formatClickDispatchDiagnosticText } from "./click-dispatch.js";
 import { buildComboboxFocusNextActions, buildElectronBroadGetTextScopeNextActions, buildFillVerificationNextActions, buildOverlayBlockerNextActions, buildScrollNoopNextActions, buildSelectorTextVisibilityNextActions, buildSourceLookupElectronNextActions, collectVisibleRefFallbackDiagnostic, formatArtifactCleanupGuidanceText, formatComboboxFocusDiagnosticText, formatElectronBroadGetTextScopeText, formatEvalResultWarningText, formatEvalStdinHintText, formatFillVerificationText, formatOverlayBlockerText, formatRecordingDependencyWarningText, formatScrollNoopDiagnosticText, formatSelectorTextVisibilityText, formatTimeoutPartialProgressText, } from "./diagnostics.js";
@@ -90,6 +91,8 @@ export function buildJsonVisibleContent(options) {
     return [{ type: "text", text: JSON.stringify(payload, null, 2) }, ...images];
 }
 export function getElectronLaunchFailureCategory(failure) {
+    if (failure.reason === "aborted")
+        return "aborted";
     if (failure.reason === "policy-blocked")
         return "policy-blocked";
     if (failure.reason === "timeout")
@@ -122,7 +125,8 @@ function formatElectronLaunchFailureDiagnostics(failure) {
         lines.push(`- Timing: ${diagnostics.elapsedMs ?? "unknown"}ms elapsed${diagnostics.timeoutMs !== undefined ? ` of ${diagnostics.timeoutMs}ms timeout` : ""}.`);
     if (diagnostics.outputCaptured === false)
         lines.push("- App stdout/stderr: not captured by this wrapper launch path.");
-    lines.push("Retry guidance: increase electron.timeoutMs, try targetType:'any', pass an explicit appPath/executablePath, quit any already-running singleton instance, then retry launch.");
+    if (failure?.reason !== "aborted")
+        lines.push("Retry guidance: increase electron.timeoutMs, try targetType:'any', pass an explicit appPath/executablePath, quit any already-running singleton instance, then retry launch.");
     return lines.join("\n");
 }
 export function buildElectronHostFailureResult(options) {
@@ -385,14 +389,15 @@ function buildAgentBrowserResultDetails(options, nextActions) {
         sessionMode: options.sessionMode,
         sessionTabCorrection: options.sessionTabCorrection,
         sessionTabTarget: options.currentSessionTabTarget,
+        sessionTabTargetUnknown: options.currentSessionTabTargetUnknown,
         refSnapshot: options.currentRefSnapshot,
         refSnapshotInvalidation: options.currentRefSnapshotInvalidation,
         namespace: options.executionPlan.namespace,
-        ...buildSessionDetailFields(options.executionPlan.sessionName, options.executionPlan.usedImplicitSession),
+        ...buildSessionDetailFields(options.executionPlan.sessionName, options.executionPlan.usedImplicitSession, options.executionPlan.namespace, options.managedSessionRestoreDisabled),
         sessionRecoveryHint: options.redactedRecoveryHint,
         startupScopedFlags: options.executionPlan.startupScopedFlags,
         stderr: options.processResult.stderr,
-        stdout: options.plainTextInspection ? options.inspectionText ?? "" : options.parseSucceeded ? undefined : options.processResult.stdout,
+        stdout: options.plainTextInspection ? options.inspectionText ?? "" : undefined,
         summary: options.presentation.summary,
         timedOut: options.processResult.timedOut || undefined,
         timeoutMs: options.processResult.timeoutMs,
@@ -428,9 +433,13 @@ export function buildFinalAgentBrowserToolResult(options) {
     const result = { content, details: redactToolDetails(details, options.exactSensitiveValues), isError: !options.succeeded };
     return options.compiledNetworkSourceLookup ? redactNetworkSourceLookupSurface(result) : result;
 }
+export function isMissingAgentBrowserBinary(processResult) {
+    return processResult.spawnError?.message.includes("ENOENT") === true;
+}
 export async function buildMissingBinaryFailureResult(options) {
-    if (!options.processResult.spawnError?.message.includes("ENOENT"))
+    if (!isMissingAgentBrowserBinary(options.processResult))
         return undefined;
+    const spawnError = options.processResult.spawnError.message;
     const errorText = buildMissingBinaryMessage();
     const managedSessionOutcome = buildManagedSessionOutcome({ activeAfter: options.managedSessionActive, activeBefore: options.managedSessionActive, attemptedSessionName: options.executionPlan.managedSessionName, command: options.executionPlan.commandInfo.command, currentSessionName: options.managedSessionName, currentSessionNamespace: options.managedSessionNamespace, previousSessionName: options.managedSessionName, sessionMode: options.sessionMode, succeeded: false });
     const managedSessionOutcomeText = formatManagedSessionOutcomeText(managedSessionOutcome);
@@ -442,5 +451,5 @@ export async function buildMissingBinaryFailureResult(options) {
         missingBinaryElectronRecord = missingBinaryElectronCleanup.record;
     }
     const textParts = [errorText, managedSessionOutcomeText, missingBinaryElectronCleanup ? `Electron cleanup after failed attach: ${missingBinaryElectronCleanup.summary}` : undefined].filter((part) => part !== undefined && part.length > 0);
-    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError: options.processResult.spawnError.message, succeeded: false }), spawnError: options.processResult.spawnError.message }, isError: true };
+    return { content: [{ type: "text", text: textParts.join("\n\n") }], details: { args: options.redactedArgs, compatibilityWorkaround: options.compatibilityWorkaround, effectiveArgs: options.redactedProcessArgs, electron: missingBinaryElectronRecord ? { action: "launch", cleanup: missingBinaryElectronCleanup, launch: missingBinaryElectronRecord, status: "failed", targets: options.electronLaunch?.targets, version: options.electronLaunch?.version } : undefined, managedSessionOutcome, namespace: options.executionPlan.namespace, nextActions: managedSessionRecoveryNextActions.length > 0 ? managedSessionRecoveryNextActions : undefined, sessionMode: options.sessionMode, sessionTabCorrection: options.sessionTabCorrection, ...buildAgentBrowserResultCategoryDetails({ args: options.redactedProcessArgs, command: options.executionPlan.commandInfo.command, errorText, failureCategory: "missing-binary", spawnError, succeeded: false }), spawnError }, isError: true };
 }

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

@@ -1,10 +1,12 @@
 import { runAgentBrowserProcess } from "../../process.js";
+import { withOwnedManagedSessionContext } from "../../managed-session-restore.js";
 import { cleanupClickDispatchProbe } from "./click-dispatch.js";
 import { applyBrowserRunStatePatch } from "./session-state.js";
 import { buildMissingBinaryFailureResult } from "./final-result.js";
 import { prepareBrowserRun } from "./prepare.js";
 import { processBrowserOutput } from "./process-output.js";
-export { closeManagedSession, getSessionContextKey } from "./session-state.js";
+export { closeManagedSession } from "./managed-session-daemon-policy.js";
+export { getSessionContextKey } from "./session-state.js";
 export async function runAgentBrowserTool(options) {
     const preparedResult = await prepareBrowserRun(options);
     applyBrowserRunStatePatch(options.state, preparedResult.kind === "ready" ? preparedResult.prepared.statePatch : preparedResult.statePatch);
@@ -12,37 +14,56 @@ export async function runAgentBrowserTool(options) {
         return preparedResult.result;
     }
     const { prepared } = preparedResult;
-    try {
-        const processResult = await runAgentBrowserProcess({
-            args: prepared.processArgs,
-            cwd: options.cwd,
-            env: prepared.executionPlan.managedSessionName ? { AGENT_BROWSER_IDLE_TIMEOUT_MS: options.implicitSessionIdleTimeoutMs } : undefined,
-            signal: options.signal,
-            stdin: prepared.processStdin,
-            timeoutMs: prepared.processTimeoutMs,
-        });
-        const missingBinaryResult = await buildMissingBinaryFailureResult({
-            compatibilityWorkaround: prepared.compatibilityWorkaround,
-            electronLaunch: prepared.electronLaunch,
-            executionPlan: prepared.executionPlan,
-            implicitSessionCloseTimeoutMs: options.implicitSessionCloseTimeoutMs,
-            managedSessionActive: options.state.managedSessionActive,
-            managedSessionName: options.state.managedSessionName,
-            managedSessionNamespace: options.state.managedSessionNamespace,
-            processResult,
-            redactedArgs: prepared.redactedArgs,
-            redactedProcessArgs: prepared.redactedProcessArgs,
-            sessionMode: prepared.sessionMode,
-            sessionTabCorrection: prepared.sessionTabCorrection,
-        });
-        if (missingBinaryResult) {
-            return missingBinaryResult;
+    const ownedManagedSession = prepared.ownedManagedSessionContext;
+    return await withOwnedManagedSessionContext(ownedManagedSession, async () => {
+        try {
+            const processResult = await runAgentBrowserProcess({
+                args: prepared.processArgs,
+                cwd: options.cwd,
+                env: ownedManagedSession
+                    ? { AGENT_BROWSER_IDLE_TIMEOUT_MS: options.implicitSessionIdleTimeoutMs }
+                    : undefined,
+                managedSessionRestoreState: options.state.managedSessionRestoreState,
+                managedStateCurrentPageUrl: prepared.priorSessionTabTarget?.url,
+                managedStatePageUrlUnknown: prepared.priorSessionTabTargetUnknown === true,
+                ownedManagedSession: ownedManagedSession !== undefined,
+                signal: options.signal,
+                stdin: prepared.processStdin,
+                timeoutMs: prepared.processTimeoutMs,
+                trustedFirstBatchTabSelection: prepared.pinnedBatchUnwrapMode !== undefined,
+            });
+            const missingBinaryResult = await buildMissingBinaryFailureResult({
+                compatibilityWorkaround: prepared.compatibilityWorkaround,
+                electronLaunch: prepared.electronLaunch,
+                executionPlan: prepared.executionPlan,
+                implicitSessionCloseTimeoutMs: options.implicitSessionCloseTimeoutMs,
+                managedSessionActive: options.state.managedSessionActive,
+                managedSessionName: options.state.managedSessionName,
+                managedSessionNamespace: options.state.managedSessionNamespace,
+                processResult,
+                redactedArgs: prepared.redactedArgs,
+                redactedProcessArgs: prepared.redactedProcessArgs,
+                sessionMode: prepared.sessionMode,
+                sessionTabCorrection: prepared.sessionTabCorrection,
+            });
+            if (missingBinaryResult)
+                return missingBinaryResult;
+            const output = await processBrowserOutput({ ...options, prepared, processResult });
+            applyBrowserRunStatePatch(options.state, output.statePatch);
+            return output.result;
         }
-        const output = await processBrowserOutput({ ...options, prepared, processResult });
-        applyBrowserRunStatePatch(options.state, output.statePatch);
-        return output.result;
-    }
-    finally {
-        await cleanupClickDispatchProbe({ cwd: options.cwd, namespace: prepared.executionPlan.namespace, probe: prepared.clickDispatchProbe, sessionName: prepared.executionPlan.sessionName });
-    }
+        finally {
+            try {
+                await cleanupClickDispatchProbe({
+                    cwd: options.cwd,
+                    namespace: prepared.executionPlan.namespace,
+                    probe: prepared.clickDispatchProbe,
+                    sessionName: prepared.executionPlan.sessionName,
+                });
+            }
+            finally {
+                await prepared.managedSessionPolicyLock?.release();
+            }
+        }
+    });
 }