pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/executable-path.js

@@ -1,19 +1,28 @@
 import { constants as fsConstants } from "node:fs";
 import { access, stat } from "node:fs/promises";
 import { delimiter, join } from "node:path";
+async function isExecutableFile(candidate) {
+    try {
+        await access(candidate, fsConstants.X_OK);
+        return (await stat(candidate)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 export async function executableExistsOnPath(command) {
-    const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
-    for (const directory of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
-        for (const extension of extensions) {
-            try {
-                const candidate = join(directory, `${command}${extension}`);
-                await access(candidate, fsConstants.X_OK);
-                if ((await stat(candidate)).isFile())
-                    return true;
-            }
-            catch {
-                // Try the next PATH candidate.
-            }
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
+        : [""];
+    const candidates = (process.env.PATH ?? "")
+        .split(delimiter)
+        .filter(Boolean)
+        .flatMap((directory) => extensions.map((extension) => join(directory, `${command}${extension}`)));
+    for (const candidate of candidates) {
+        // Respect PATH/PATHEXT precedence and stop probing after the first executable.
+        // oxlint-disable-next-line no-await-in-loop
+        if (await isExecutableFile(candidate)) {
+            return true;
         }
     }
     return false;

package/dist/extensions/agent-browser/lib/execution-cwd.js

@@ -2,49 +2,66 @@ import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join } from "node:path";
 import { isRecord } from "./parsing.js";
 function isDirectoryOwner(source) {
-    if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source))
+    if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source)) {
         return true;
+    }
     const directories = [source.baseDir, isAbsolute(source.path) ? dirname(source.path) : undefined];
-    return directories.some(directory => {
-        if (!directory || !isAbsolute(directory))
+    return directories.some((directory) => {
+        if (directory === undefined || directory.length === 0 || !isAbsolute(directory)) {
             return false;
+        }
         try {
-            return JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).name === "pi-change-working-dir";
+            const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+            return isRecord(manifest) && manifest.name === "pi-change-working-dir";
         }
         catch {
             return false;
         }
     });
 }
+function validateDirectoryReply(result) {
+    const invalid = "pi-change-working-dir returned an invalid execution directory. Update the extension and restart Pi.";
+    if (!isRecord(result) || Array.isArray(result)) {
+        throw new Error(invalid);
+    }
+    if (result.error !== undefined) {
+        throw new Error(typeof result.error === "string" && result.error.length > 0 ? result.error : invalid);
+    }
+    if (typeof result.cwd !== "string" || !isAbsolute(result.cwd) || result.cwd.includes("\0")) {
+        throw new Error(invalid);
+    }
+    return result.cwd;
+}
 /** The synchronous owner reply is captured before any browser policy, queue, or child await. */
 export function resolveExecutionCwd(pi, ctx) {
-    const request = { sessionManager: ctx.sessionManager };
+    const request = {
+        sessionManager: ctx.sessionManager,
+    };
     pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
     const result = request.result;
     if (result !== undefined) {
-        const invalid = "pi-change-working-dir returned an invalid execution directory. Update the extension and restart Pi.";
-        if (!isRecord(result) || Array.isArray(result))
-            throw new Error(invalid);
-        if (result.error !== undefined)
-            throw new Error(typeof result.error === "string" && result.error.length > 0 ? result.error : invalid);
-        if (typeof result.cwd !== "string" || !isAbsolute(result.cwd) || result.cwd.includes("\0"))
-            throw new Error(invalid);
-        return result.cwd;
-    }
-    if (pi.getAllTools().some(tool => tool.name === "change_dir" && isDirectoryOwner(tool.sourceInfo))
-        || pi.getCommands().some(command => /^cwd(?::\d+)?$/.test(command.name) && isDirectoryOwner(command.sourceInfo))) {
+        return validateDirectoryReply(result);
+    }
+    if (pi
+        .getAllTools()
+        .some((tool) => tool.name === "change_dir" && isDirectoryOwner(tool.sourceInfo)) ||
+        pi
+            .getCommands()
+            .some((command) => /^cwd(?::\d+)?$/.test(command.name) && isDirectoryOwner(command.sourceInfo))) {
         throw new Error("Update pi-change-working-dir and restart Pi to use agent_browser with the selected working directory.");
     }
     return ctx.cwd;
 }
 export function getBrowserCwdError(cwd) {
     try {
-        if (statSync(cwd).isDirectory())
+        if (statSync(cwd).isDirectory()) {
             return undefined;
+        }
     }
     catch (error) {
-        if (!["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+        if (!isRecord(error) || (error.code !== "ENOENT" && error.code !== "ENOTDIR")) {
             throw error;
+        }
     }
     return `Browser launch directory is unavailable: ${cwd}. Restore that directory, or explicitly use sessionMode: "fresh" without --session, or --config from the selected execution directory. The existing browser was left untouched.`;
 }

package/dist/extensions/agent-browser/lib/fs-utils.js

@@ -1,4 +1,4 @@
-import { access, stat } from "node:fs/promises";
+import { access } from "node:fs/promises";
 export async function pathExists(path) {
     try {
         await access(path);
@@ -8,11 +8,3 @@ export async function pathExists(path) {
         return false;
     }
 }
-export async function directoryExists(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,160 +1,201 @@
 import { isRecord } from "../parsing.js";
+import { isStringArray } from "./shared.js";
 import { AGENT_BROWSER_ELECTRON_ACTIONS, AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_LIST_FIELDS, AGENT_BROWSER_ELECTRON_PROBE_FIELDS, AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, } from "./types.js";
-function validateOptionalNonEmptyString(input, fieldName) {
+function optionalString(input, fieldName) {
     const value = input[fieldName];
-    if (value === undefined)
+    if (value === undefined) {
         return {};
+    }
     if (typeof value !== "string" || value.trim().length === 0) {
         return { error: `electron.${fieldName} must be a non-empty string when provided.` };
     }
     return { value: value.trim() };
 }
-function validateOptionalElectronStringArray(input, fieldName) {
+function optionalInteger(input, fieldName) {
     const value = input[fieldName];
-    if (value === undefined)
+    if (value === undefined) {
+        return {};
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        return { error: `electron.${fieldName} must be a positive integer when provided.` };
+    }
+    return { value };
+}
+function stringArray(value) {
+    if (!isStringArray(value)) {
         return undefined;
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim().length === 0)) {
-        return `electron.${fieldName} must be an array of non-empty strings when provided.`;
     }
-    return undefined;
+    return value.map((item) => item.trim());
 }
-function validateOptionalElectronEnum(input, fieldName, values) {
+function arrayError(input, fieldName) {
     const value = input[fieldName];
-    if (value === undefined)
+    if (value === undefined) {
         return undefined;
-    if (typeof value !== "string" || !values.includes(value)) {
-        return `electron.${fieldName} must be one of: ${values.join(", ")}.`;
     }
-    return undefined;
-}
-function getReservedElectronAppArg(appArgs) {
-    return appArgs?.find((arg) => {
-        const trimmed = arg.trim();
-        return trimmed === "--" || AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS.some((reserved) => trimmed === reserved || trimmed.startsWith(`${reserved}=`));
-    });
-}
-function validateElectronLaunchAppArgs(appArgs) {
-    const reservedArg = getReservedElectronAppArg(appArgs);
-    return reservedArg
-        ? `electron.appArgs must not include wrapper-owned launch flag ${reservedArg}.`
+    const parsed = stringArray(value);
+    return parsed === undefined || parsed.some((item) => item.length === 0)
+        ? `electron.${fieldName} must be an array of non-empty strings when provided.`
         : undefined;
 }
-function validateOptionalElectronPositiveInteger(input, fieldName) {
+function enumError(input, fieldName, values) {
     const value = input[fieldName];
-    if (value === undefined)
-        return {};
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        return { error: `electron.${fieldName} must be a positive integer when provided.` };
+    if (value === undefined) {
+        return undefined;
     }
-    return { value };
-}
-function onlyAllowedElectronFields(input, action, allowedFields) {
-    return Object.keys(input).find((fieldName) => !allowedFields.has(fieldName))
-        ? `electron.${action} does not support electron.${Object.keys(input).find((fieldName) => !allowedFields.has(fieldName))}.`
+    return typeof value !== "string" || !values.includes(value)
+        ? `electron.${fieldName} must be one of: ${values.join(", ")}.`
         : undefined;
 }
-export function compileAgentBrowserElectron(input) {
-    if (!isRecord(input))
-        return { error: "electron must be an object." };
-    const action = input.action;
-    if (typeof action !== "string" || !AGENT_BROWSER_ELECTRON_ACTIONS.includes(action)) {
-        return { error: `electron.action must be one of: ${AGENT_BROWSER_ELECTRON_ACTIONS.join(", ")}.` };
-    }
-    for (const fieldName of ["query", "appPath", "appName", "bundleId", "executablePath", "launchId"]) {
-        const validation = validateOptionalNonEmptyString(input, fieldName);
-        if (validation.error)
-            return { error: validation.error };
-    }
-    for (const fieldName of ["appArgs", "allow", "deny"]) {
-        const error = validateOptionalElectronStringArray(input, fieldName);
-        if (error)
-            return { error };
-    }
-    const handoffError = validateOptionalElectronEnum(input, "handoff", AGENT_BROWSER_ELECTRON_HANDOFFS);
-    if (handoffError)
-        return { error: handoffError };
-    const targetTypeError = validateOptionalElectronEnum(input, "targetType", AGENT_BROWSER_ELECTRON_TARGET_TYPES);
-    if (targetTypeError)
-        return { error: targetTypeError };
-    for (const fieldName of ["maxResults", "timeoutMs"]) {
-        const validation = validateOptionalElectronPositiveInteger(input, fieldName);
-        if (validation.error)
-            return { error: validation.error };
-    }
-    if (input.all !== undefined && input.all !== true) {
-        return { error: "electron.all must be true when provided." };
-    }
-    if (action === "list") {
-        const unsupportedListField = Object.keys(input).find((fieldName) => !AGENT_BROWSER_ELECTRON_LIST_FIELDS.has(fieldName));
-        if (unsupportedListField) {
-            return { error: `electron.list only supports query and maxResults; remove electron.${unsupportedListField}.` };
+function commonError(input) {
+    for (const field of ["query", "appPath", "appName", "bundleId", "executablePath", "launchId"]) {
+        const error = optionalString(input, field).error;
+        if (error !== undefined) {
+            return error;
+        }
+    }
+    for (const field of ["appArgs", "allow", "deny"]) {
+        const error = arrayError(input, field);
+        if (error !== undefined) {
+            return error;
         }
-        return {
-            compiled: {
-                action: "list",
-                maxResults: validateOptionalElectronPositiveInteger(input, "maxResults").value,
-                query: validateOptionalNonEmptyString(input, "query").value,
-            },
-        };
     }
-    if (action === "probe") {
-        const unsupportedProbeField = Object.keys(input).find((fieldName) => !AGENT_BROWSER_ELECTRON_PROBE_FIELDS.has(fieldName));
-        if (unsupportedProbeField) {
-            return { error: `electron.probe only supports action, launchId, and timeoutMs; remove electron.${unsupportedProbeField}.` };
+    return (enumError(input, "handoff", AGENT_BROWSER_ELECTRON_HANDOFFS) ??
+        enumError(input, "targetType", AGENT_BROWSER_ELECTRON_TARGET_TYPES) ??
+        numericError(input));
+}
+function numericError(input) {
+    for (const field of ["maxResults", "timeoutMs"]) {
+        const error = optionalInteger(input, field).error;
+        if (error !== undefined) {
+            return error;
         }
-        const launchId = validateOptionalNonEmptyString(input, "launchId").value;
-        const timeoutMs = validateOptionalElectronPositiveInteger(input, "timeoutMs").value;
+    }
+    return input.all !== undefined && input.all !== true
+        ? "electron.all must be true when provided."
+        : undefined;
+}
+function unsupportedField(input, allowed) {
+    return Object.keys(input).find((field) => !allowed.includes(field));
+}
+function allowedFieldError(input, action, allowed) {
+    const field = unsupportedField(input, allowed);
+    return field === undefined ? undefined : `electron.${action} does not support electron.${field}.`;
+}
+function compileLaunch(input) {
+    const fieldError = allowedFieldError(input, "launch", [
+        "action",
+        "allow",
+        "appArgs",
+        "appName",
+        "appPath",
+        "bundleId",
+        "deny",
+        "executablePath",
+        "handoff",
+        "targetType",
+        "timeoutMs",
+    ]);
+    if (fieldError !== undefined) {
+        return { error: fieldError };
+    }
+    const appArgs = stringArray(input.appArgs);
+    const reservedArg = appArgs?.find((arg) => arg === "--" ||
+        AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS.some((reserved) => arg === reserved || arg.startsWith(`${reserved}=`)));
+    if (reservedArg !== undefined) {
+        return { error: `electron.appArgs must not include wrapper-owned launch flag ${reservedArg}.` };
+    }
+    const providedTargets = ["appPath", "appName", "bundleId", "executablePath"].filter((field) => input[field] !== undefined);
+    if (providedTargets.length !== 1) {
         return {
-            compiled: {
-                action: "probe",
-                ...(launchId ? { launchId } : {}),
-                ...(timeoutMs ? { timeoutMs } : {}),
-            },
+            error: "electron.launch requires exactly one of appPath, appName, bundleId, or executablePath.",
         };
     }
-    if (action === "launch") {
-        const allowedFields = new Set(["action", "allow", "appArgs", "appName", "appPath", "bundleId", "deny", "executablePath", "handoff", "targetType", "timeoutMs"]);
-        const unsupportedFieldError = onlyAllowedElectronFields(input, action, allowedFields);
-        if (unsupportedFieldError)
-            return { error: unsupportedFieldError };
-        const appArgs = input.appArgs?.map((item) => item.trim());
-        const appArgsError = validateElectronLaunchAppArgs(appArgs);
-        if (appArgsError)
-            return { error: appArgsError };
-        const targetFields = ["appPath", "appName", "bundleId", "executablePath"];
-        const providedTargets = targetFields.filter((fieldName) => input[fieldName] !== undefined);
-        if (providedTargets.length !== 1) {
-            return { error: "electron.launch requires exactly one of appPath, appName, bundleId, or executablePath." };
-        }
+    return {
+        compiled: {
+            action: "launch",
+            allow: stringArray(input.allow),
+            appArgs,
+            deny: stringArray(input.deny),
+            appName: optionalString(input, "appName").value,
+            appPath: optionalString(input, "appPath").value,
+            bundleId: optionalString(input, "bundleId").value,
+            executablePath: optionalString(input, "executablePath").value,
+            handoff: AGENT_BROWSER_ELECTRON_HANDOFFS.find((value) => value === input.handoff) ?? "snapshot",
+            targetType: AGENT_BROWSER_ELECTRON_TARGET_TYPES.find((value) => value === input.targetType) ?? "page",
+            timeoutMs: optionalInteger(input, "timeoutMs").value,
+        },
+    };
+}
+function compileList(input) {
+    const field = unsupportedField(input, AGENT_BROWSER_ELECTRON_LIST_FIELDS);
+    if (field !== undefined) {
+        return { error: `electron.list only supports query and maxResults; remove electron.${field}.` };
+    }
+    return {
+        compiled: {
+            action: "list",
+            maxResults: optionalInteger(input, "maxResults").value,
+            query: optionalString(input, "query").value,
+        },
+    };
+}
+function compileProbe(input) {
+    const field = unsupportedField(input, AGENT_BROWSER_ELECTRON_PROBE_FIELDS);
+    if (field !== undefined) {
         return {
-            compiled: {
-                action: "launch",
-                allow: input.allow?.map((item) => item.trim()),
-                appArgs,
-                deny: input.deny?.map((item) => item.trim()),
-                appName: validateOptionalNonEmptyString(input, "appName").value,
-                appPath: validateOptionalNonEmptyString(input, "appPath").value,
-                bundleId: validateOptionalNonEmptyString(input, "bundleId").value,
-                executablePath: validateOptionalNonEmptyString(input, "executablePath").value,
-                handoff: input.handoff ?? "snapshot",
-                targetType: input.targetType ?? "page",
-                timeoutMs: validateOptionalElectronPositiveInteger(input, "timeoutMs").value,
-            },
+            error: `electron.probe only supports action, launchId, and timeoutMs; remove electron.${field}.`,
         };
     }
-    const allowedFields = new Set(["action", "all", "launchId", "timeoutMs"]);
-    const unsupportedFieldError = onlyAllowedElectronFields(input, action, allowedFields);
-    if (unsupportedFieldError)
-        return { error: unsupportedFieldError };
+    const launchId = optionalString(input, "launchId").value;
+    const timeoutMs = optionalInteger(input, "timeoutMs").value;
+    return {
+        compiled: {
+            action: "probe",
+            ...(launchId !== undefined ? { launchId } : {}),
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        },
+    };
+}
+function compileStatusOrCleanup(input, action) {
+    const error = allowedFieldError(input, action, ["action", "all", "launchId", "timeoutMs"]);
+    if (error !== undefined) {
+        return { error };
+    }
     if (input.all === true && input.launchId !== undefined) {
         return { error: `electron.${action} accepts launchId or all, not both.` };
     }
     return {
         compiled: {
-            action: action,
-            all: input.all === true || undefined,
-            launchId: validateOptionalNonEmptyString(input, "launchId").value,
-            timeoutMs: validateOptionalElectronPositiveInteger(input, "timeoutMs").value,
+            action,
+            all: input.all === true ? true : undefined,
+            launchId: optionalString(input, "launchId").value,
+            timeoutMs: optionalInteger(input, "timeoutMs").value,
         },
     };
 }
+export function compileAgentBrowserElectron(input) {
+    if (!isRecord(input)) {
+        return { error: "electron must be an object." };
+    }
+    const action = AGENT_BROWSER_ELECTRON_ACTIONS.find((value) => value === input.action);
+    if (action === undefined) {
+        return {
+            error: `electron.action must be one of: ${AGENT_BROWSER_ELECTRON_ACTIONS.join(", ")}.`,
+        };
+    }
+    const error = commonError(input);
+    if (error !== undefined) {
+        return { error };
+    }
+    switch (action) {
+        case "launch":
+            return compileLaunch(input);
+        case "list":
+            return compileList(input);
+        case "probe":
+            return compileProbe(input);
+        case "status":
+        case "cleanup":
+            return compileStatusOrCleanup(input, action);
+    }
+}