pi-agent-browser-native 0.9.5 → 0.9.7

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

@@ -1,243 +0,0 @@
-import { isRecord } from "../parsing.js";
-import { getSelectValues } from "./shared.js";
-import { AGENT_BROWSER_SEMANTIC_ACTIONS, AGENT_BROWSER_SEMANTIC_LOCATORS, } from "./types.js";
-export function getCompiledSemanticActionCommandIndex(compiled) {
-    return compiled.args[0] === "--session" ? 2 : 0;
-}
-export function getCompiledSemanticActionSessionPrefix(compiled) {
-    const commandIndex = getCompiledSemanticActionCommandIndex(compiled);
-    return commandIndex > 0 ? compiled.args.slice(0, commandIndex) : [];
-}
-export function isCompiledSemanticActionFindCommand(compiled) {
-    return (compiled !== undefined &&
-        compiled.action !== "select" &&
-        compiled.args[getCompiledSemanticActionCommandIndex(compiled)] === "find");
-}
-function sessionArgs(session, args) {
-    return typeof session === "string" ? ["--session", session, ...args] : [...args];
-}
-function textError(action, text) {
-    if (text !== undefined && typeof text !== "string") {
-        return "semanticAction.text must be a string when provided.";
-    }
-    if (action === "fill" && (typeof text !== "string" || text.length === 0)) {
-        return `semanticAction.text is required for ${action}.`;
-    }
-    if (action !== "fill" && text !== undefined) {
-        return "semanticAction.text is only supported for fill actions.";
-    }
-    return undefined;
-}
-function directAction(input, action, selector) {
-    if (input.locator !== undefined ||
-        input.value !== undefined ||
-        input.role !== undefined ||
-        input.name !== undefined) {
-        return {
-            error: "semanticAction.selector cannot be combined with locator, value, role, or name; use selector for a direct click/check/fill target or locator fields for find-based actions.",
-        };
-    }
-    const error = textError(action, input.text);
-    if (error !== undefined) {
-        return { error };
-    }
-    const args = sessionArgs(input.session, [action, selector]);
-    if (action === "fill" && typeof input.text === "string") {
-        args.push(input.text);
-    }
-    return { compiled: { action, selector, args } };
-}
-function roleSelect(input) {
-    const { role, name } = input;
-    if (typeof role !== "string" || !/^(?:combobox|listbox)$/i.test(role)) {
-        return { error: "semanticAction.role must be combobox or listbox for locator=role select." };
-    }
-    if (typeof name !== "string" || name.trim().length === 0) {
-        return { error: "semanticAction.name is required for locator=role select." };
-    }
-    const options = getSelectValues({ value: input.value, values: input.values }, "semanticAction");
-    if (options.error !== undefined) {
-        return { error: options.error };
-    }
-    return {
-        compiled: {
-            action: "select",
-            locator: "role",
-            values: options.values,
-            args: sessionArgs(input.session, [
-                "find",
-                "role",
-                role,
-                "select",
-                ...options.values,
-                "--name",
-                name,
-            ]),
-        },
-    };
-}
-function labelSelect(input) {
-    if (typeof input.value !== "string" || input.value.trim().length === 0) {
-        return {
-            error: "semanticAction.value must be the accessible label text for locator=label select.",
-        };
-    }
-    if (input.role !== undefined || input.name !== undefined) {
-        return { error: "semanticAction.role and name are only supported for locator=role select." };
-    }
-    const options = getSelectValues({ values: input.values }, "semanticAction");
-    if (options.error !== undefined) {
-        return {
-            error: options.error.includes("required")
-                ? "semanticAction.values is required for locator=label select (value is the label text)."
-                : options.error,
-        };
-    }
-    return {
-        compiled: {
-            action: "select",
-            locator: "label",
-            values: options.values,
-            args: sessionArgs(input.session, ["find", "label", input.value, "select", ...options.values]),
-        },
-    };
-}
-function selectAction(input) {
-    if (input.text !== undefined) {
-        return {
-            error: "semanticAction.text is not supported for select; use value or values for option values.",
-        };
-    }
-    if (typeof input.selector === "string" && input.selector.trim().length > 0) {
-        return directSelect(input, input.selector);
-    }
-    if (input.selector !== undefined) {
-        return { error: "semanticAction.selector must be a non-empty string when provided." };
-    }
-    if (input.locator === undefined) {
-        return { error: "semanticAction.selector or semanticAction.locator is required for select." };
-    }
-    if (input.locator !== "role" && input.locator !== "label") {
-        return {
-            error: "semanticAction select locator must be role or label; use selector plus value/values for other targets.",
-        };
-    }
-    return input.locator === "role" ? roleSelect(input) : labelSelect(input);
-}
-function directSelect(input, selector) {
-    if (input.locator !== undefined || input.role !== undefined || input.name !== undefined) {
-        return {
-            error: "semanticAction.selector cannot be combined with locator, role, or name for select; use selector plus value/values, or locator fields plus values.",
-        };
-    }
-    const options = getSelectValues(input, "semanticAction");
-    if (options.error !== undefined) {
-        return { error: options.error };
-    }
-    return {
-        compiled: {
-            action: "select",
-            selector,
-            values: options.values,
-            args: sessionArgs(input.session, ["select", selector, ...options.values]),
-        },
-    };
-}
-function locatorValueError(input) {
-    if (input.value !== undefined &&
-        (typeof input.value !== "string" || input.value.trim().length === 0)) {
-        return "semanticAction.value must be a non-empty string when provided.";
-    }
-    if (input.role !== undefined &&
-        (typeof input.role !== "string" || input.role.trim().length === 0)) {
-        return "semanticAction.role must be a non-empty string when provided.";
-    }
-    return undefined;
-}
-function roleFieldsError(input, locator) {
-    if (input.role !== undefined && locator !== "role") {
-        return "semanticAction.role is only supported for locator=role.";
-    }
-    if (input.role !== undefined && input.value !== undefined && input.role !== input.value) {
-        return "semanticAction.role must match value when both are provided for locator=role.";
-    }
-    if (input.name !== undefined &&
-        (locator !== "role" || typeof input.name !== "string" || input.name.length === 0)) {
-        return "semanticAction.name is only supported as a non-empty string for locator=role.";
-    }
-    return undefined;
-}
-function findAction(input, action) {
-    const locator = AGENT_BROWSER_SEMANTIC_LOCATORS.find((value) => value === input.locator);
-    if (locator === undefined) {
-        return {
-            error: `semanticAction.locator must be one of: ${AGENT_BROWSER_SEMANTIC_LOCATORS.join(", ")}.`,
-        };
-    }
-    const valueError = locatorValueError(input);
-    if (valueError !== undefined) {
-        return { error: valueError };
-    }
-    const locatorValue = locator === "role" && typeof input.role === "string" ? input.role : input.value;
-    if (typeof locatorValue !== "string" || locatorValue.trim().length === 0) {
-        return {
-            error: locator === "role"
-                ? "semanticAction.value or semanticAction.role must be a non-empty string for locator=role."
-                : "semanticAction.value must be a non-empty string.",
-        };
-    }
-    const error = textError(action, input.text) ?? roleFieldsError(input, locator);
-    if (error !== undefined) {
-        return { error };
-    }
-    return {
-        compiled: { action, locator, args: findActionArgs(input, { action, locator, locatorValue }) },
-    };
-}
-function findActionArgs(input, target) {
-    const args = sessionArgs(input.session, [
-        "find",
-        target.locator,
-        target.locatorValue,
-        target.action,
-    ]);
-    if (target.action === "fill" && typeof input.text === "string") {
-        args.push(input.text);
-    }
-    if (target.locator === "role" && typeof input.name === "string") {
-        args.push("--name", input.name);
-    }
-    return args;
-}
-function nonSelectAction(input, action) {
-    if (input.values !== undefined) {
-        return { error: "semanticAction.values is only supported for select actions." };
-    }
-    if (input.selector === undefined) {
-        return findAction(input, action);
-    }
-    if (typeof input.selector !== "string" || input.selector.trim().length === 0) {
-        return { error: "semanticAction.selector must be a non-empty string when provided." };
-    }
-    return directAction(input, action, input.selector);
-}
-export function compileAgentBrowserSemanticAction(input) {
-    if (!isRecord(input)) {
-        return { error: "semanticAction must be an object." };
-    }
-    const action = AGENT_BROWSER_SEMANTIC_ACTIONS.find((value) => value === input.action);
-    if (action === undefined) {
-        return {
-            error: `semanticAction.action must be one of: ${AGENT_BROWSER_SEMANTIC_ACTIONS.join(", ")}.`,
-        };
-    }
-    if (input.session !== undefined &&
-        (typeof input.session !== "string" || input.session.trim().length === 0)) {
-        return { error: "semanticAction.session must be a non-empty string when provided." };
-    }
-    const normalized = {
-        ...input,
-        name: typeof input.name === "string" && input.name.trim().length === 0 ? undefined : input.name,
-    };
-    return action === "select" ? selectAction(normalized) : nonSelectAction(normalized, action);
-}

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

@@ -1,48 +0,0 @@
-import { isRecord } from "../parsing.js";
-import { SOURCE_LOOKUP_DEFAULT_MAX_WORKSPACE_FILES, SOURCE_LOOKUP_MAX_WORKSPACE_FILES, } from "./types.js";
-function isString(value) {
-    return typeof value === "string";
-}
-export function isStringArray(value) {
-    return Array.isArray(value) && value.every(isString);
-}
-export function getSelectValues(input, context) {
-    const rawValue = input.value;
-    const rawValues = input.values;
-    if (rawValue !== undefined && rawValues !== undefined) {
-        return { error: `${context}.value and ${context}.values cannot both be provided for select.` };
-    }
-    if (rawValues !== undefined) {
-        if (!isStringArray(rawValues) ||
-            rawValues.length === 0 ||
-            rawValues.some((value) => value.trim().length === 0)) {
-            return {
-                error: `${context}.values must be a non-empty array of non-empty strings for select.`,
-            };
-        }
-        return { values: rawValues };
-    }
-    if (typeof rawValue === "string" && rawValue.trim().length > 0) {
-        return { values: [rawValue] };
-    }
-    return { error: `${context}.value or ${context}.values is required for select.` };
-}
-export function getBatchResultItems(data) {
-    return Array.isArray(data) ? data.filter(isRecord) : [];
-}
-export function getCommandNameFromBatchItem(item) {
-    const command = item.command;
-    return Array.isArray(command) && typeof command[0] === "string" ? command[0] : undefined;
-}
-export function validateLookupMaxWorkspaceFiles(value, fieldName) {
-    if (value === undefined) {
-        return { value: SOURCE_LOOKUP_DEFAULT_MAX_WORKSPACE_FILES };
-    }
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        return { error: `${fieldName} must be a positive integer when provided.` };
-    }
-    if (value > SOURCE_LOOKUP_MAX_WORKSPACE_FILES) {
-        return { error: `${fieldName} must be ${SOURCE_LOOKUP_MAX_WORKSPACE_FILES} or less.` };
-    }
-    return { value };
-}

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

@@ -1,65 +0,0 @@
-export const DEFAULT_SESSION_MODE = "auto";
-export const AGENT_BROWSER_CODE_MAX_TIMEOUT_MS = 300_000;
-export const AGENT_BROWSER_SEMANTIC_ACTIONS = ["check", "click", "fill", "select"];
-export const AGENT_BROWSER_SEMANTIC_LOCATORS = [
-    "alt",
-    "label",
-    "placeholder",
-    "role",
-    "testid",
-    "text",
-    "title",
-];
-const AGENT_BROWSER_JOB_STEP_ACTIONS = [
-    "open",
-    "click",
-    "fill",
-    "type",
-    "select",
-    "wait",
-    "assertText",
-    "assertUrl",
-    "waitForDownload",
-    "screenshot",
-    "snapshot",
-];
-export const AGENT_BROWSER_QA_LOAD_STATES = ["domcontentloaded", "load", "networkidle"];
-export const AGENT_BROWSER_ELECTRON_ACTIONS = [
-    "list",
-    "launch",
-    "status",
-    "cleanup",
-    "probe",
-];
-export const AGENT_BROWSER_ELECTRON_HANDOFFS = ["connect", "tabs", "snapshot"];
-export const AGENT_BROWSER_ELECTRON_TARGET_TYPES = ["page", "webview", "any"];
-export const AGENT_BROWSER_ELECTRON_LIST_FIELDS = [
-    "action",
-    "query",
-    "maxResults",
-];
-export const AGENT_BROWSER_ELECTRON_PROBE_FIELDS = [
-    "action",
-    "launchId",
-    "timeoutMs",
-];
-export const AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS = [
-    "--user-data-dir",
-    "--remote-debugging-port",
-    "--remote-debugging-address",
-    "--remote-debugging-pipe",
-];
-export const SOURCE_LOOKUP_WORKSPACE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
-export const SOURCE_LOOKUP_IGNORED_DIRECTORIES = new Set([
-    ".git",
-    "node_modules",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    "out",
-    "tmp",
-    "temp",
-]);
-export const SOURCE_LOOKUP_DEFAULT_MAX_WORKSPACE_FILES = 2_000;
-export const SOURCE_LOOKUP_MAX_WORKSPACE_FILES = 5_000;

package/dist/extensions/agent-browser/lib/json-schema.js

@@ -1,65 +0,0 @@
-const OPTIONAL_SCHEMA = Symbol("pi-agent-browser-optional-schema");
-function withOptions(schema, options) {
-    return { ...schema, ...options };
-}
-function literalType(value) {
-    const valueType = typeof value;
-    return valueType === "string" || valueType === "number" || valueType === "boolean"
-        ? valueType
-        : undefined;
-}
-function propertySchema(schema) {
-    const clone = { ...schema };
-    if (OPTIONAL_SCHEMA in clone) {
-        delete clone[OPTIONAL_SCHEMA];
-    }
-    return clone;
-}
-function isOptional(schema) {
-    return OPTIONAL_SCHEMA in schema && schema[OPTIONAL_SCHEMA] === true;
-}
-function unsafeSchema(schema) {
-    return schema;
-}
-const nativeJsonSchemaBuilder = {
-    Array(items, options) {
-        return withOptions({ type: "array", items }, options);
-    },
-    Boolean(options) {
-        return withOptions({ type: "boolean" }, options);
-    },
-    Integer(options) {
-        return withOptions({ type: "integer" }, options);
-    },
-    Literal(value, options) {
-        const type = literalType(value);
-        return withOptions(type !== undefined ? { type, const: value } : { const: value }, options);
-    },
-    Number(options) {
-        return withOptions({ type: "number" }, options);
-    },
-    Object(properties, options) {
-        const required = globalThis.Object.entries(properties)
-            .filter(([, schema]) => !isOptional(schema))
-            .map(([key]) => key);
-        return withOptions({
-            type: "object",
-            properties: globalThis.Object.fromEntries(globalThis.Object.entries(properties).map(([key, schema]) => [
-                key,
-                propertySchema(schema),
-            ])),
-            ...(required.length > 0 ? { required } : {}),
-        }, options);
-    },
-    Optional(schema) {
-        return { ...schema, [OPTIONAL_SCHEMA]: true };
-    },
-    String(options) {
-        return withOptions({ type: "string" }, options);
-    },
-    Union(types, options) {
-        return withOptions({ anyOf: types }, options);
-    },
-    Unsafe: unsafeSchema,
-};
-export const JsonSchema = nativeJsonSchemaBuilder;

package/dist/extensions/agent-browser/lib/launch-scoped-flags.js

@@ -1,212 +0,0 @@
-import { findCommandStartIndex } from "./argv-descriptor.js";
-import { isBooleanFlagEnabled } from "./argv-grammar.js";
-export const LAUNCH_SCOPED_FLAG_DEFINITIONS = [
-    {
-        flag: "--auto-connect",
-        reason: "attaches to an already-running browser at launch time instead of reusing an existing named session",
-    },
-    {
-        flag: "--allowed-domains",
-        reason: "installs upstream network and WebRTC containment on a fresh controllable browser context",
-    },
-    {
-        flag: "--namespace",
-        reason: "selects the upstream daemon/socket and restore-state namespace before session lookup",
-    },
-    {
-        flag: "--cdp",
-        reason: "selects the browser/CDP endpoint used when an upstream session is launched",
-    },
-    {
-        flag: "--ca-cert",
-        reason: "selects isolated Chromium CA trust and may relaunch the browser",
-    },
-    {
-        flag: "--no-ca-cert",
-        reason: "clears retained isolated Chromium CA trust and may relaunch the browser",
-    },
-    {
-        flag: "--enable",
-        reason: "selects built-in page init scripts before the upstream browser session is launched",
-    },
-    {
-        flag: "--engine",
-        reason: "selects the browser engine used for the upstream launch",
-    },
-    {
-        flag: "--executable-path",
-        reason: "selects the browser executable used for the upstream launch",
-    },
-    {
-        flag: "--webgpu",
-        reason: "selects the platform-specific WebGPU browser launch preset",
-    },
-    {
-        flag: "--no-webmcp",
-        reason: "selects whether locally launched Chrome enables experimental WebMCP support",
-    },
-    {
-        flag: "--init-script",
-        reason: "registers page init scripts before the upstream browser session is launched",
-    },
-    {
-        flag: "--idle-timeout",
-        reason: "configures background browser lifecycle for the launched session",
-    },
-    {
-        flag: "--args",
-        reason: "selects raw Chrome arguments for the browser launch",
-    },
-    {
-        flag: "--user-agent",
-        reason: "selects the browser user agent at launch time",
-    },
-    {
-        flag: "--headed",
-        reason: "selects whether the launched browser has a visible window",
-    },
-    {
-        flag: "--device",
-        reason: "selects the provider device for the upstream launch",
-    },
-    {
-        flag: "--profile",
-        reason: "selects Chrome profile state for the upstream launch",
-    },
-    {
-        flag: "--provider",
-        reason: "selects the upstream browser provider for the launch",
-    },
-    {
-        flag: "-p",
-        reason: "selects the upstream browser provider for the launch",
-    },
-    {
-        flag: "--session-name",
-        reason: "selects upstream saved auth/session state for the launch",
-    },
-    {
-        flag: "--restore",
-        reason: "selects upstream saved auth/session restore state for the launch",
-    },
-    {
-        flag: "--restore-save",
-        reason: "configures upstream restore auto-save policy for the launched session",
-    },
-    {
-        flag: "--restore-check-url",
-        reason: "configures restore validation before the launched session can auto-save",
-    },
-    {
-        flag: "--restore-check-text",
-        reason: "configures restore validation before the launched session can auto-save",
-    },
-    {
-        flag: "--restore-check-fn",
-        reason: "configures restore validation before the launched session can auto-save",
-    },
-    {
-        flag: "--state",
-        reason: "loads persisted upstream browser/auth state at launch time",
-    },
-];
-export const LAUNCH_SCOPED_FLAGS = LAUNCH_SCOPED_FLAG_DEFINITIONS.map((definition) => definition.flag);
-export const LAUNCH_SCOPED_FLAG_LABEL = LAUNCH_SCOPED_FLAGS.join(", ");
-export const OPEN_RESULT_TAB_CORRECTION_FLAGS = new Set([
-    "--profile",
-    "--restore",
-    "--session-name",
-    "--state",
-]);
-/** Launch modes that must never be combined with wrapper-managed restore state. */
-export const MANAGED_RESTORE_INCOMPATIBLE_FLAGS = [
-    "--restore",
-    "--restore-save",
-    "--restore-check-url",
-    "--restore-check-text",
-    "--restore-check-fn",
-    "--allowed-domains",
-    "--profile",
-    "--state",
-    "--cdp",
-    "--auto-connect",
-    "--session-name",
-    "--provider",
-    "-p",
-    "--executable-path",
-    "--extension",
-    "--init-script",
-    "--enable",
-    "--args",
-    "--user-agent",
-    "--proxy",
-    "--proxy-bypass",
-    "--ca-cert",
-    "--ignore-https-errors",
-    "--allow-file-access",
-    "--webgpu",
-    "--device",
-    "--engine",
-];
-/** Nonempty upstream env defaults that can replace or mutate the browser receiving restored state. */
-export const MANAGED_RESTORE_INCOMPATIBLE_ENVS = [
-    "AGENT_BROWSER_RESTORE",
-    "AGENT_BROWSER_RESTORE_SAVE",
-    "AGENT_BROWSER_RESTORE_CHECK_URL",
-    "AGENT_BROWSER_RESTORE_CHECK_TEXT",
-    "AGENT_BROWSER_RESTORE_CHECK_FN",
-    "AGENT_BROWSER_ALLOWED_DOMAINS",
-    "AGENT_BROWSER_PROFILE",
-    "AGENT_BROWSER_STATE",
-    "AGENT_BROWSER_CDP",
-    "AGENT_BROWSER_SESSION_NAME",
-    "AGENT_BROWSER_PROVIDER",
-    "AGENT_BROWSER_EXECUTABLE_PATH",
-    "AGENT_BROWSER_EXTENSIONS",
-    "AGENT_BROWSER_INIT_SCRIPTS",
-    "AGENT_BROWSER_ENABLE",
-    "AGENT_BROWSER_ARGS",
-    "AGENT_BROWSER_USER_AGENT",
-    "AGENT_BROWSER_PROXY",
-    "AGENT_BROWSER_PROXY_BYPASS",
-    "AGENT_BROWSER_CA_CERT",
-    "AGENT_BROWSER_PLUGINS",
-    "AGENT_BROWSER_IOS_DEVICE",
-    "AGENT_BROWSER_IOS_UDID",
-    "AGENT_BROWSER_ENGINE",
-    "HTTP_PROXY",
-    "HTTPS_PROXY",
-    "ALL_PROXY",
-    "http_proxy",
-    "https_proxy",
-    "all_proxy",
-];
-/** Boolean launch mutators block restore only when enabled. */
-export const MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS = [
-    "AGENT_BROWSER_AUTO_CONNECT",
-    "AGENT_BROWSER_IGNORE_HTTPS_ERRORS",
-    "AGENT_BROWSER_ALLOW_FILE_ACCESS",
-    "AGENT_BROWSER_WEBGPU",
-];
-export function hasLaunchScopedFlagToken(args, flag) {
-    const commandStartIndex = findCommandStartIndex(args);
-    const command = commandStartIndex === undefined ? undefined : args[commandStartIndex];
-    return args.some((token, index) => {
-        if (token.startsWith(`${flag}=`)) {
-            return flag === "--restore";
-        }
-        if (token !== flag) {
-            return false;
-        }
-        if (flag === "--auto-connect") {
-            return isBooleanFlagEnabled(args, flag);
-        }
-        if (flag === "--state" &&
-            command === "wait" &&
-            commandStartIndex !== undefined &&
-            index > commandStartIndex) {
-            return false;
-        }
-        return true;
-    });
-}