pi-agent-browser-native 0.3.0 → 0.6.5

package/dist/extensions/agent-browser/lib/argv-descriptor.js

@@ -1,4 +1,4 @@
-import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS, optionalGlobalValueFlagConsumesNext } from "./argv-grammar.js";
+import { GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES, VALUE_FLAGS, optionalGlobalValueFlagConsumesNext, stripUpstreamGlobalFlags } from "./argv-grammar.js";
 import { isOpenNavigationCommand } from "./command-taxonomy.js";
 function isBooleanLiteral(token) {
     const normalized = token?.trim().toLowerCase();
@@ -33,6 +33,33 @@ export function extractCommandTokens(args) {
     const commandStartIndex = findCommandStartIndex(args);
     return commandStartIndex === undefined ? [] : args.slice(commandStartIndex);
 }
+export function extractUpstreamCommandTokens(args) {
+    return stripUpstreamGlobalFlags(extractCommandTokens(args));
+}
+export function parseWaitCommandTokens(commandTokens) {
+    if (commandTokens[0] !== "wait")
+        return {};
+    const considered = commandTokens.slice(1).map((token, offset) => ({ index: offset + 1, token }));
+    const timeoutIndex = considered.findIndex((entry) => entry.token === "--timeout");
+    if (timeoutIndex >= 0)
+        considered.splice(timeoutIndex, Math.min(2, considered.length - timeoutIndex));
+    for (const flags of [["--url", "-u"], ["--load", "-l"], ["--fn", "-f"], ["--text", "-t"]]) {
+        const match = considered.find((entry) => flags.includes(entry.token));
+        if (match)
+            return { subcommand: match.token };
+    }
+    const download = considered.find((entry) => entry.token === "--download" || entry.token === "-d");
+    if (download) {
+        const downloadPathIndex = download.index + 1;
+        const candidate = commandTokens[downloadPathIndex];
+        return {
+            downloadPath: candidate && !candidate.startsWith("--") ? candidate : undefined,
+            downloadPathIndex: candidate && !candidate.startsWith("--") ? downloadPathIndex : undefined,
+            subcommand: download.token,
+        };
+    }
+    return { subcommand: considered[0]?.token };
+}
 function getOpenCommandTarget(commandTokens) {
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
@@ -51,10 +78,13 @@ function getOpenCommandTarget(commandTokens) {
     return undefined;
 }
 export function parseCommandInfoFromTokens(commandTokens) {
-    const command = commandTokens[0];
+    const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
+    const command = upstreamCommandTokens[0];
     return {
         command,
-        subcommand: isOpenNavigationCommand(command) ? getOpenCommandTarget(commandTokens) : commandTokens[1],
+        subcommand: isOpenNavigationCommand(command)
+            ? getOpenCommandTarget(upstreamCommandTokens)
+            : command === "wait" ? parseWaitCommandTokens(upstreamCommandTokens).subcommand : upstreamCommandTokens[1],
     };
 }
 export function parseCommandInfo(args) {
@@ -62,8 +92,10 @@ export function parseCommandInfo(args) {
 }
 export function parseArgvDescriptor(args) {
     const commandTokens = extractCommandTokens(args);
+    const upstreamCommandTokens = stripUpstreamGlobalFlags(commandTokens);
     return {
         commandInfo: parseCommandInfoFromTokens(commandTokens),
         commandTokens,
+        upstreamCommandTokens,
     };
 }

package/dist/extensions/agent-browser/lib/argv-grammar.js

@@ -12,6 +12,7 @@ export const GLOBAL_VALUE_FLAGS = [
     "--restore-check-fn",
     "--proxy",
     "--proxy-bypass",
+    "--ca-cert",
     "--headers",
     "--executable-path",
     "--extension",
@@ -37,6 +38,7 @@ export const GLOBAL_VALUE_FLAGS = [
     "--idle-timeout",
 ];
 export const COMMAND_VALUE_FLAGS = [
+    "--allowed-origins",
     "--baseline",
     "--body",
     "--categories",
@@ -47,6 +49,7 @@ export const COMMAND_VALUE_FLAGS = [
     "--domain",
     "--expires",
     "--filter",
+    "--frame",
     "--fn",
     "--label",
     "--load",
@@ -57,6 +60,7 @@ export const COMMAND_VALUE_FLAGS = [
     "--prefix",
     "--path",
     "--port",
+    "--params",
     "--resource-type",
     "--resource-types",
     "--sameSite",
@@ -90,6 +94,13 @@ export const GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES = new Set([
     "--ignore-https-errors",
     "--json",
     "--no-auto-dialog",
+    "--no-ca-cert",
+    "--no-pin-tab",
+    "--no-webmcp",
+    "--offline",
+    "--pin-tab",
+    "--quick",
+    "--fix",
     "--quiet",
     "-q",
     "--verbose",
@@ -148,7 +159,7 @@ export function canonicalizeAgentBrowserNamespace(value) {
     }
     return normalized.replace(/[-_]+$/u, "") || undefined;
 }
-function foldAgentBrowserFilesystemIdentity(value, platform) {
+export function foldAgentBrowserFilesystemIdentity(value, platform) {
     if (platform !== "darwin" && platform !== "win32")
         return value;
     // APFS aliases include full Unicode folds such as ß/SS and ς/Σ, not just ASCII case.
@@ -160,7 +171,11 @@ export function getAgentBrowserSessionIdentityKey(sessionName, namespace, platfo
     const canonicalSessionName = foldAgentBrowserFilesystemIdentity(sessionName, platform);
     return identityNamespace ? `${identityNamespace}\0${canonicalSessionName}` : canonicalSessionName;
 }
-/** Mirror upstream 0.33.2 global parsing: full argv, no `--` sentinel, and only global value payloads are skipped. */
+export function isAgentBrowserSessionIdentityKeyInNamespace(identityKey, namespace) {
+    const prefix = getAgentBrowserSessionIdentityKey("", namespace);
+    return prefix ? identityKey.startsWith(prefix) : !identityKey.includes("\0");
+}
+/** Mirror upstream global parsing: full argv, no `--` sentinel, and only global value payloads are skipped. */
 export function scanUpstreamGlobalFlagOccurrences(args, targetFlag) {
     const occurrences = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -257,6 +272,39 @@ export function optionalGlobalValueFlagConsumesNext(flag, nextToken) {
         return false;
     return !isKnownCommandToken(nextToken);
 }
+export function projectUpstreamGlobalFlags(args) {
+    const indices = [];
+    const tokens = [];
+    let seenCommand = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token.startsWith("--restore="))
+            continue;
+        if (token === "--restore") {
+            if (!seenCommand && optionalGlobalValueFlagConsumesNext(token, args[index + 1]))
+                index += 1;
+            continue;
+        }
+        if (PREVALIDATED_VALUE_FLAGS.has(token)) {
+            index += 1;
+            continue;
+        }
+        if (GLOBAL_BOOLEAN_FLAGS_WITH_OPTIONAL_VALUES.has(token)) {
+            if (["true", "false"].includes(args[index + 1] ?? ""))
+                index += 1;
+            continue;
+        }
+        tokens.push(token);
+        indices.push(index);
+        if (isKnownCommandToken(token))
+            seenCommand = true;
+    }
+    return { indices, tokens };
+}
+/** Mirror upstream clean_args: remove global flags wherever they appear before command parsing. */
+export function stripUpstreamGlobalFlags(args) {
+    return projectUpstreamGlobalFlags(args).tokens;
+}
 export function stripSessionlessShapeGlobalFlags(commandTokens) {
     const stripped = [];
     for (let index = 0; index < commandTokens.length; index += 1) {

package/dist/extensions/agent-browser/lib/batch-lifecycle.js

@@ -0,0 +1,71 @@
+import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
+import { isCloseAllCommand, isCloseCommand } from "./command-taxonomy.js";
+import { isRecord } from "./parsing.js";
+function getRowBrowserLaunched(row) {
+    const result = isRecord(row.result) ? row.result : isRecord(row.data) ? row.data : undefined;
+    const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : isRecord(result?.lifecycle) ? result.lifecycle : undefined;
+    const effectiveLaunch = isRecord(lifecycle?.effectiveLaunch) ? lifecycle.effectiveLaunch : undefined;
+    return typeof effectiveLaunch?.browserLaunched === "boolean" ? effectiveLaunch.browserLaunched : undefined;
+}
+export function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
+    if (!Array.isArray(data))
+        return false;
+    return data.some((row, index) => {
+        if (!isRecord(row) || row.success !== true)
+            return false;
+        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
+            ? row.command
+            : fallbackCommands[index];
+        return rowCommand ? isCloseAllCommand(extractUpstreamCommandTokens(rowCommand)) : false;
+    });
+}
+export function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
+    if (!Array.isArray(rows))
+        return undefined;
+    let sawClose = false;
+    let endsClosed = false;
+    let browserActiveAfterClose = false;
+    let recordingClosedAfterBatch = false;
+    let statePath;
+    for (const [index, row] of rows.entries()) {
+        if (!isRecord(row))
+            continue;
+        const stepSucceeded = row.success === true;
+        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
+            ? row.command
+            : fallbackCommands[index];
+        const browserLaunched = getRowBrowserLaunched(row);
+        if (!rowCommand) {
+            if (sawClose && browserLaunched !== false) {
+                endsClosed = false;
+                browserActiveAfterClose = true;
+                recordingClosedAfterBatch = false;
+            }
+            continue;
+        }
+        const [command, subcommand] = extractUpstreamCommandTokens(rowCommand);
+        if (stepSucceeded && isCloseCommand(command)) {
+            sawClose = true;
+            endsClosed = true;
+            browserActiveAfterClose = false;
+            recordingClosedAfterBatch = true;
+            const result = isRecord(row.result) ? row.result : isRecord(row.data) ? row.data : undefined;
+            statePath = typeof result?.statePath === "string" ? result.statePath : undefined;
+        }
+        else if (sawClose && command === "record") {
+            if (browserLaunched !== false) {
+                endsClosed = false;
+                browserActiveAfterClose = true;
+            }
+            if (stepSucceeded && subcommand === "stop")
+                recordingClosedAfterBatch = true;
+            else if (stepSucceeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart"))
+                recordingClosedAfterBatch = false;
+        }
+        else if (sawClose && browserLaunched !== false) {
+            endsClosed = false;
+            browserActiveAfterClose = true;
+        }
+    }
+    return sawClose ? { endsClosed, recordingClosedAfterBatch, statePath } : undefined;
+}

package/dist/extensions/agent-browser/lib/command-policy.js

@@ -5,8 +5,7 @@ const EMPTY_BOOLEAN_FLAGS = new Set();
 const JSON_BOOLEAN_FLAGS = new Set(["--json"]);
 const AUTH_SAVE_BOOLEAN_FLAGS = new Set(["--json", "--password-stdin"]);
 const AUTH_SAVE_VALUE_FLAGS = new Set(["--password", "--password-selector", "--submit-selector", "--url", "--username", "--username-selector"]);
-const DASHBOARD_SUBCOMMANDS = new Set(["start", "stop"]);
-const DASHBOARD_START_VALUE_FLAGS = new Set(["--port"]);
+const DASHBOARD_VALUE_FLAGS = new Set(["--allowed-origins", "--port"]);
 const DOCTOR_BOOLEAN_FLAGS = new Set(["--fix", "--headed", "--json", "--offline", "--quick", "--webgpu"]);
 const INSTALL_BOOLEAN_FLAGS = new Set(["--with-deps", "-d"]);
 const STATE_SESSIONLESS_SUBCOMMANDS = new Set(["list", "show", "clear", "clean", "rename"]);
@@ -26,11 +25,9 @@ function isSessionlessAuthCommand(commandTokens) {
 }
 function isSessionlessDashboardCommand(commandTokens) {
     const [, subcommand, ...rest] = commandTokens;
-    if (subcommand === undefined)
-        return true;
-    if (!DASHBOARD_SUBCOMMANDS.has(subcommand))
-        return false;
-    return subcommand === "start" ? hasOnlyOptionFlags(rest, JSON_BOOLEAN_FLAGS, DASHBOARD_START_VALUE_FLAGS) : rest.length === 0;
+    if (subcommand === "stop")
+        return rest.length === 0;
+    return hasOnlyOptionFlags(subcommand === "start" ? rest : commandTokens.slice(1), JSON_BOOLEAN_FLAGS, DASHBOARD_VALUE_FLAGS);
 }
 function isSessionlessStateCommand(commandTokens) {
     const [, subcommand, firstArg, secondArg, ...rest] = commandTokens;
@@ -96,5 +93,5 @@ function isSessionlessCommand(commandTokens) {
     return false;
 }
 export function needsManagedSession(descriptor) {
-    return !isSessionlessCommand(descriptor.commandTokens);
+    return !isSessionlessCommand(descriptor.upstreamCommandTokens);
 }

package/dist/extensions/agent-browser/lib/command-taxonomy.js

@@ -1,6 +1,7 @@
 const ADDITIONAL_COMMAND_TOKENS = [
-    "a11y", "auth", "chat", "clipboard", "confirm", "connect", "dashboard", "deny", "device", "dialog", "diff", "doctor", "errors", "eval", "find", "frame", "get", "highlight", "inspect", "install", "is", "mcp", "plugin", "plugins", "profiles", "profiler", "react", "record", "removeinitscript", "session", "set", "skills", "snapshot", "state", "stream", "trace", "upgrade", "vitals", "wait", "web-vitals", "window",
+    "a11y", "auth", "chat", "clipboard", "confirm", "connect", "dashboard", "deny", "device", "dialog", "diff", "doctor", "errors", "eval", "find", "frame", "get", "highlight", "inspect", "install", "is", "mcp", "plugin", "plugins", "profiles", "profiler", "react", "record", "removeinitscript", "session", "set", "skills", "snapshot", "state", "stream", "trace", "upgrade", "vitals", "wait", "web-vitals", "webmcp", "window",
 ];
+const WEBMCP_PAGE_MUTATION_SUBCOMMANDS = new Set(["invoke", "result", "cancel"]);
 const COMMAND_CAPABILITIES = [
     {
         command: "back",
@@ -61,6 +62,10 @@ const COMMAND_CAPABILITIES = [
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "diff",
+        guardsPageRefs: true,
+    },
     {
         command: "download",
         eligibleForPageChangeSummary: true,
@@ -92,6 +97,10 @@ const COMMAND_CAPABILITIES = [
         command: "find",
         eligibleForElectronHealthProbe: true,
     },
+    {
+        command: "frame",
+        guardsPageRefs: true,
+    },
     {
         command: "focus",
         guardsPageRefs: true,
@@ -104,6 +113,14 @@ const COMMAND_CAPABILITIES = [
         navigationObservable: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "get",
+        guardsPageRefs: true,
+    },
+    {
+        command: "highlight",
+        guardsPageRefs: true,
+    },
     {
         command: "hover",
         eligibleForPageChangeSummary: true,
@@ -111,6 +128,10 @@ const COMMAND_CAPABILITIES = [
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
+    {
+        command: "is",
+        guardsPageRefs: true,
+    },
     {
         command: "keydown",
         eligibleForElectronHealthProbe: true,
@@ -185,10 +206,12 @@ const COMMAND_CAPABILITIES = [
     {
         command: "screenshot",
         eligibleForPageChangeSummary: true,
+        guardsPageRefs: true,
     },
     {
         command: "scroll",
         eligibleForPageChangeSummary: true,
+        guardsPageRefs: true,
         invalidatesBatchRefs: true,
         triggersPostMutationSnapshot: true,
     },
@@ -281,11 +304,14 @@ export function normalizeCommandName(command) {
 export function isCloseCommand(command) {
     return hasCommandCapability(command, "closesSession");
 }
+export function isCloseAllCommand(commandTokens) {
+    return isCloseCommand(commandTokens[0]) && commandTokens.slice(1).includes("--all");
+}
 export function isOpenNavigationCommand(command) {
     return hasCommandCapability(command, "openNavigation");
 }
-export function isReadOnlyDiagnosticSessionTargetCommand(command, _subcommand) {
-    return hasCommandCapability(command, "readOnlyDiagnosticSessionTarget");
+export function isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) {
+    return hasCommandCapability(command, "readOnlyDiagnosticSessionTarget") || (command === "webmcp" && subcommand === "list");
 }
 export function isSessionTabPinningExcludedCommand(command) {
     return hasCommandCapability(command, "excludedFromPinning");
@@ -293,8 +319,19 @@ export function isSessionTabPinningExcludedCommand(command) {
 export function isSessionTabPostCommandCorrectionExcludedCommand(command) {
     return hasCommandCapability(command, "excludedFromPostCommandCorrection");
 }
-export function isRefInvalidatingBatchCommand(command) {
-    return hasCommandCapability(command, "invalidatesBatchRefs");
+/** Upstream 0.33.2 record start swaps to a fresh active page before its already-active check, so even a failed start can replace the page; record restart navigates the current page only when a URL operand (any fourth token, mirroring upstream's positional slot) is present. */
+export function isRecordPageTransitionCommand(tokens) {
+    if (tokens[0] !== "record")
+        return false;
+    if (tokens[1] === "start")
+        return true;
+    return tokens[1] === "restart" && tokens.length >= 4;
+}
+export function isWebMcpPageMutationCommand(tokens) {
+    return isWebMcpPageMutation(tokens[0], tokens[1]);
+}
+export function isRefInvalidatingBatchCommand(step) {
+    return hasCommandCapability(step[0], "invalidatesBatchRefs") || isRecordPageTransitionCommand(step) || isWebMcpPageMutationCommand(step);
 }
 export function isRefGuardedCommand(command) {
     return hasCommandCapability(command, "guardsPageRefs");
@@ -302,17 +339,21 @@ export function isRefGuardedCommand(command) {
 export function isElectronPostCommandHealthCommand(command) {
     return hasCommandCapability(command, "eligibleForElectronHealthProbe");
 }
-export function isNavigationObservableCommandName(command) {
-    return hasCommandCapability(command, "navigationObservable");
+function isWebMcpPageMutation(command, subcommand) {
+    return command === "webmcp" && WEBMCP_PAGE_MUTATION_SUBCOMMANDS.has(subcommand ?? "");
+}
+export function isNavigationObservableCommandName(command, subcommand) {
+    return hasCommandCapability(command, "navigationObservable") || isWebMcpPageMutation(command, subcommand);
 }
 export function isUnverifiedPageTransitionCommand(command, subcommand) {
     return ["back", "connect", "eval", "forward", "reload"].includes(command ?? "")
         || (command === "state" && subcommand === "load")
-        || (command === "tab" && subcommand !== undefined && !["list", "new"].includes(subcommand));
+        || (command === "tab" && subcommand !== undefined && !["list", "new"].includes(subcommand))
+        || isWebMcpPageMutation(command, subcommand);
 }
-export function isPageMutationCommand(command) {
-    return hasCommandCapability(command, "triggersPostMutationSnapshot");
+export function isPageMutationCommand(command, subcommand) {
+    return hasCommandCapability(command, "triggersPostMutationSnapshot") || isWebMcpPageMutation(command, subcommand);
 }
-export function isPageChangeSummaryCommand(command) {
-    return hasCommandCapability(command, "eligibleForPageChangeSummary");
+export function isPageChangeSummaryCommand(command, subcommand) {
+    return hasCommandCapability(command, "eligibleForPageChangeSummary") || isWebMcpPageMutation(command, subcommand);
 }

package/dist/extensions/agent-browser/lib/config-policy.js

@@ -7,10 +7,11 @@ import { join, resolve } from "node:path";
 /** @typedef {"global" | "project" | "override"} ConfigLayerScope */
 /** @typedef {"literal" | "env" | "command"} CredentialSourceKind */
 /** @typedef {"exa" | "brave"} WebSearchProvider */
+/** @typedef {"auto" | "fast" | "instant" | "deep-lite" | "deep" | "deep-reasoning"} ExaSearchType */
 /** @typedef {"exaApiKey" | "braveApiKey"} WebSearchProviderConfigKey */
 /** @typedef {{ provider: WebSearchProvider; apiKeyEnv: string; configKey: WebSearchProviderConfigKey; label: string }} WebSearchProviderDescriptor */
 /** @typedef {{ name: string; policy?: BrowserDefaultProfilePolicy }} BrowserDefaultProfileConfig */
-/** @typedef {{ enabled?: boolean; preferredProvider?: WebSearchProvider; braveApiKey?: string; exaApiKey?: string }} WebSearchConfig */
+/** @typedef {{ enabled?: boolean; preferredProvider?: WebSearchProvider; defaultSearchType?: ExaSearchType; braveApiKey?: string; exaApiKey?: string }} WebSearchConfig */
 /** @typedef {{ defaultProfile?: BrowserDefaultProfileConfig; executablePath?: string }} BrowserConfig */
 /** @typedef {{ version?: 1; webSearch?: WebSearchConfig; browser?: BrowserConfig }} AgentBrowserConfig */
 /** @typedef {{ config: AgentBrowserConfig; path: string; scope: ConfigLayerScope }} ConfigLayer */
@@ -45,6 +46,8 @@ export const WEB_SEARCH_PROVIDER_DESCRIPTORS = Object.freeze({
 export const WEB_SEARCH_PROVIDERS = Object.freeze(["exa", "brave"]);
 /** @type {WebSearchProvider} */
 export const DEFAULT_WEB_SEARCH_PROVIDER = "exa";
+/** @type {readonly ExaSearchType[]} */
+export const EXA_SEARCH_TYPES = Object.freeze(["auto", "fast", "instant", "deep-lite", "deep", "deep-reasoning"]);
 /** @type {Readonly<Record<WebSearchProvider, WebSearchProviderConfigKey>>} */
 export const WEB_SEARCH_PROVIDER_CONFIG_KEYS = Object.freeze({
     exa: WEB_SEARCH_PROVIDER_DESCRIPTORS.exa.configKey,
@@ -182,6 +185,24 @@ export function validateWebSearchProvider(value, path, errors) {
     }
     return provider;
 }
+/**
+ * @param {unknown} value
+ * @param {string} path
+ * @param {string[]} errors
+ * @returns {ExaSearchType | undefined}
+ */
+function validateExaSearchType(value, path, errors) {
+    if (value === undefined)
+        return undefined;
+    const searchType = validateString(value, path, errors)?.trim();
+    if (searchType === undefined)
+        return undefined;
+    if (!EXA_SEARCH_TYPES.includes(/** @type {ExaSearchType} */ (searchType))) {
+        errors.push(`${path} must be one of ${EXA_SEARCH_TYPES.join(", ")}.`);
+        return undefined;
+    }
+    return /** @type {ExaSearchType} */ (searchType);
+}
 /**
  * @param {unknown} value
  * @param {string} path
@@ -251,6 +272,9 @@ export function validateAgentBrowserConfig(value, path, errors, warnings) {
             const preferredProvider = validateWebSearchProvider(value.webSearch.preferredProvider, `${path}.webSearch.preferredProvider`, errors);
             if (preferredProvider)
                 webSearch.preferredProvider = preferredProvider;
+            const defaultSearchType = validateExaSearchType(value.webSearch.defaultSearchType, `${path}.webSearch.defaultSearchType`, errors);
+            if (defaultSearchType)
+                webSearch.defaultSearchType = defaultSearchType;
             for (const provider of WEB_SEARCH_PROVIDERS) {
                 const descriptor = getWebSearchProviderDescriptor(provider);
                 const apiKey = validateString(value.webSearch[descriptor.configKey], `${path}.webSearch.${descriptor.configKey}`, errors);

package/dist/extensions/agent-browser/lib/config.js

@@ -2,7 +2,7 @@ import { exec as execCallback } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { SECRET_COMMAND_TIMEOUT_MS, buildAgentBrowserConfigState, getAgentBrowserConfigPaths, getWebSearchCredentialSource, getWebSearchProviderOrder, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, } from "./config-policy.js";
-export { AGENT_BROWSER_CONFIG_ENV, BRAVE_API_KEY_ENV, CONFIG_RELATIVE_PATH, DEFAULT_WEB_SEARCH_PROVIDER, EXA_API_KEY_ENV, GLOBAL_CONFIG_RELATIVE_PATH, SECRET_COMMAND_TIMEOUT_MS, WEB_SEARCH_PROVIDER_CONFIG_KEYS, WEB_SEARCH_PROVIDER_DESCRIPTORS, WEB_SEARCH_PROVIDER_ENV_VARS, WEB_SEARCH_PROVIDERS, buildAgentBrowserConfigState, buildWebSearchCredentialSources, canRegisterWebSearchTool, classifyCredentialSource, formatBrowserExecutableStatus, formatBrowserProfileStatus, getAgentBrowserConfigPaths, getCredentialSourceSummary, getGlobalAgentBrowserConfigPath, getProjectAgentBrowserConfigPath, getWebSearchCredentialSource, getWebSearchProviderConfigKey, getWebSearchProviderDescriptor, getWebSearchProviderEnvVar, getWebSearchProviderLabel, getWebSearchProviderOrder, hasPotentialCredentialSource, isPlaintextCredentialValue, isProjectSafeCredentialValueForProvider, isWebSearchProvider, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, summarizeConfigFiles, validateAgentBrowserConfig, validateWebSearchProvider, } from "./config-policy.js";
+export { AGENT_BROWSER_CONFIG_ENV, BRAVE_API_KEY_ENV, CONFIG_RELATIVE_PATH, DEFAULT_WEB_SEARCH_PROVIDER, EXA_API_KEY_ENV, EXA_SEARCH_TYPES, GLOBAL_CONFIG_RELATIVE_PATH, SECRET_COMMAND_TIMEOUT_MS, WEB_SEARCH_PROVIDER_CONFIG_KEYS, WEB_SEARCH_PROVIDER_DESCRIPTORS, WEB_SEARCH_PROVIDER_ENV_VARS, WEB_SEARCH_PROVIDERS, buildAgentBrowserConfigState, buildWebSearchCredentialSources, canRegisterWebSearchTool, classifyCredentialSource, formatBrowserExecutableStatus, formatBrowserProfileStatus, getAgentBrowserConfigPaths, getCredentialSourceSummary, getGlobalAgentBrowserConfigPath, getProjectAgentBrowserConfigPath, getWebSearchCredentialSource, getWebSearchProviderConfigKey, getWebSearchProviderDescriptor, getWebSearchProviderEnvVar, getWebSearchProviderLabel, getWebSearchProviderOrder, hasPotentialCredentialSource, isPlaintextCredentialValue, isProjectSafeCredentialValueForProvider, isWebSearchProvider, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigLayer, resolveEnvInterpolations, summarizeConfigFiles, validateAgentBrowserConfig, validateWebSearchProvider, } from "./config-policy.js";
 const exec = promisify(execCallback);
 async function readConfigLayer(path, scope, errors, warnings) {
     let raw;

package/dist/extensions/agent-browser/lib/input-modes/job.js

@@ -213,15 +213,6 @@ export function compileAgentBrowserJob(input) {
     }
     return { compiled: { args: failFast ? ["batch", "--bail"] : ["batch"], failFast, stdin: JSON.stringify(steps.map((step) => step.args)), steps } };
 }
-export function isHttpOrHttpsUrl(url) {
-    try {
-        const protocol = new URL(url).protocol;
-        return protocol === "http:" || protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
 function describeQaChecksRun(checks) {
     const parts = [`load:${checks.loadState}`];
     if (checks.expectedText.length > 0)
@@ -266,7 +257,7 @@ export function buildQaCompactPassText(options) {
         lines.push(`Page: ${pageParts.join(" — ")}`);
     lines.push(`Checks run: ${describeQaChecksRun(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
     if (options.checks.diagnosticsResetAtStart && (options.checks.checkNetwork || options.checks.checkConsole || options.checks.checkErrors)) {
-        lines.push("Diagnostic reset: URL QA cleared enabled network/console/page-error buffers before opening the target; reset rows in details.batchSteps are not counted as current-page failures.");
+        lines.push("Diagnostic isolation: URL QA clears enabled network/console buffers, then snapshots any page-error residue before opening the target. Only unchanged residue is ignored because upstream page-error clear is not reliable.");
     }
     if (options.checks.attached && !options.checks.diagnosticsResetAtStart && (options.checks.checkNetwork || options.checks.checkConsole || options.checks.checkErrors)) {
         lines.push("Attached diagnostics: existing upstream session console/network/error buffers were preserved; rows may include events from before qa.attached started.");
@@ -280,6 +271,19 @@ export function buildQaCompactPassText(options) {
     lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
     return lines.join("\n");
 }
+export function buildQaCompactFailureText(options) {
+    const lines = [options.qaPreset.summary];
+    const pageParts = [options.page?.title, options.page?.url].filter((part) => typeof part === "string" && part.length > 0);
+    if (pageParts.length > 0)
+        lines.push(`Page: ${pageParts.join(" — ")}`);
+    if (options.qaPreset.failedChecks.length > 0)
+        lines.push("Failed checks:", ...options.qaPreset.failedChecks.map((failure) => `- ${failure}`));
+    if (options.qaPreset.warnings.length > 0)
+        lines.push("Warnings:", ...options.qaPreset.warnings.map((warning) => `- ${warning}`));
+    lines.push(`Checks run: ${describeQaChecksRun(options.checks)} (${options.batchStepCount} batch step${options.batchStepCount === 1 ? "" : "s"})`);
+    lines.push("Full diagnostic matrix: see details.qaPreset and details.batchSteps.");
+    return lines.join("\n");
+}
 const QA_VISIBLE_TEXT_TIMEOUT_MS = 5_000;
 function formatQaExpectedTextPreview(text) {
     return JSON.stringify(text.length > 80 ? `${text.slice(0, 77)}...` : text);
@@ -348,6 +352,34 @@ function extractQaTextAssertionResultText(item) {
     }
     return undefined;
 }
+function qaErrorSignature(error) {
+    if (typeof error === "string")
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function subtractQaBaselineErrors(errors, baselineErrors) {
+    const baselineCounts = new Map();
+    for (const error of baselineErrors) {
+        const signature = qaErrorSignature(error);
+        baselineCounts.set(signature, (baselineCounts.get(signature) ?? 0) + 1);
+    }
+    let ignoredCount = 0;
+    const novelErrors = errors.filter((error) => {
+        const signature = qaErrorSignature(error);
+        const count = baselineCounts.get(signature) ?? 0;
+        if (count === 0)
+            return true;
+        baselineCounts.set(signature, count - 1);
+        ignoredCount += 1;
+        return false;
+    });
+    return { ignoredCount, novelErrors };
+}
 function isDiagnosticResetCommand(item) {
     const command = item.command;
     if (!Array.isArray(command) || !command.every((token) => typeof token === "string"))
@@ -372,17 +404,29 @@ export function analyzeQaPresetResults(data, compiled) {
         return undefined;
     const failedChecks = [];
     const warnings = [];
-    for (const item of items) {
+    const baselineErrorIndex = compiled?.checks.diagnosticsResetAtStart && compiled.checks.checkErrors
+        ? compiled.steps.findIndex((step) => step.generatedFrom === "qa.errorBaselineAfterClear")
+        : -1;
+    const baselineErrorItem = baselineErrorIndex >= 0 ? items[baselineErrorIndex] : undefined;
+    const baselineErrorResult = isRecord(baselineErrorItem?.result) ? baselineErrorItem.result : undefined;
+    const baselineErrors = Array.isArray(baselineErrorResult?.errors) ? baselineErrorResult.errors : [];
+    for (const [index, item] of items.entries()) {
         if (item.success === false) {
             failedChecks.push(`${getCommandNameFromBatchItem(item) ?? "step"} failed`);
         }
+        if (index === baselineErrorIndex)
+            continue;
         const result = isRecord(item.result) ? item.result : undefined;
         const commandName = getCommandNameFromBatchItem(item);
         if (compiled?.checks.diagnosticsResetAtStart && isDiagnosticResetCommand(item)) {
             continue;
         }
         if (commandName === "errors" && Array.isArray(result?.errors) && result.errors.length > 0) {
-            failedChecks.push(`${result.errors.length} page error(s)`);
+            const { ignoredCount, novelErrors } = subtractQaBaselineErrors(result.errors, baselineErrors);
+            if (novelErrors.length > 0)
+                failedChecks.push(`${novelErrors.length} page error(s)`);
+            if (ignoredCount > 0)
+                warnings.push(`${ignoredCount} post-clear page error residue row(s) ignored as unchanged`);
         }
         if (commandName === "console" && Array.isArray(result?.messages)) {
             const errorCount = result.messages.filter((message) => isRecord(message) && /error/i.test(String(message.type ?? message.level ?? ""))).length;
@@ -477,11 +521,15 @@ export function compileAgentBrowserQaPreset(input) {
         steps.push({ action: "wait", args: ["network", "requests", "--clear"] });
     if (diagnosticsResetAtStart && checkConsole)
         steps.push({ action: "wait", args: ["console", "--clear"] });
-    if (diagnosticsResetAtStart && checkErrors)
+    if (diagnosticsResetAtStart && checkErrors) {
         steps.push({ action: "wait", args: ["errors", "--clear"] });
+        steps.push({ action: "wait", args: ["errors"], generatedFrom: "qa.errorBaselineAfterClear" });
+    }
     if (!attached && normalizedUrl)
         steps.push({ action: "open", args: ["open", normalizedUrl] });
     steps.push({ action: "wait", args: ["wait", "--load", loadState] });
+    if (checkConsole || checkErrors)
+        steps.push({ action: "wait", args: ["wait", "150"], generatedFrom: "qa.diagnosticSettle" });
     for (const text of expectedText) {
         steps.push({ action: "assertText", args: ["wait", "--fn", buildQaVisibleTextPredicate(text), "--timeout", String(QA_VISIBLE_TEXT_TIMEOUT_MS)] });
     }

package/dist/extensions/agent-browser/lib/input-modes/lookups.js

@@ -261,8 +261,8 @@ export function compileAgentBrowserNetworkSourceLookup(input) {
         return { error: "networkSourceLookup.filter must be a non-empty string when provided." };
     if (requestId !== undefined && (typeof requestId !== "string" || requestId.trim().length === 0))
         return { error: "networkSourceLookup.requestId must be a non-empty string when provided." };
-    if (namespace !== undefined && (typeof namespace !== "string" || namespace.trim().length === 0))
-        return { error: "networkSourceLookup.namespace must be a non-empty string when provided." };
+    if (namespace !== undefined && (typeof namespace !== "string" || (namespace !== "" && namespace.trim().length === 0)))
+        return { error: "networkSourceLookup.namespace must be a non-empty string or the empty default namespace when provided." };
     if (session !== undefined && (typeof session !== "string" || session.trim().length === 0))
         return { error: "networkSourceLookup.session must be a non-empty string when provided." };
     if (url !== undefined && (typeof url !== "string" || url.trim().length === 0))