pi-agent-browser-native 0.9.5 → 0.9.7

package/dist/extensions/agent-browser/lib/process-child.js

@@ -1,284 +0,0 @@
-import { spawn } from "node:child_process";
-import { platform as processPlatform } from "node:process";
-import { spawn as crossSpawn } from "cross-spawn";
-import { appendProcessOutputTail, ProcessStdout } from "./process-stdout.js";
-import { getErrorCode, normalizeProcessError } from "./process-errors.js";
-const MAX_BUFFERED_STDERR_CHARS = 32_000;
-const EXIT_STDIO_GRACE_MS = 100;
-async function terminateSpawnedChild(child, signal) {
-    if (processPlatform === "win32" && child.pid !== undefined && child.pid !== 0) {
-        // Observe taskkill before completing; keep the shell alive while traversing descendants.
-        const killed = await new Promise((resolve) => {
-            const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
-                stdio: "ignore",
-            });
-            killer.once("error", () => resolve(false));
-            killer.once("close", (code) => resolve(code === 0));
-        });
-        if (killed) {
-            return;
-        }
-    }
-    child.kill(signal);
-}
-export function resolveSpawnedChildExitCode(input) {
-    // Close -> wrapper timeout -> post-exit fallback -> spawn failure.
-    if (input.closeCode !== null && input.closeCode !== undefined) {
-        return input.closeCode;
-    }
-    if (input.timedOut) {
-        return 124;
-    }
-    if (input.useExitFallback && input.exitCode !== null && input.exitCode !== undefined) {
-        return input.exitCode;
-    }
-    return input.spawnError ? 127 : 0;
-}
-function destroySpawnedChildStreams(child) {
-    child.stdin.destroy();
-    child.stdout.destroy();
-    child.stderr.destroy();
-}
-class ChildCompletion {
-    complete;
-    context;
-    exited = false;
-    exitCode = null;
-    timer;
-    completed = false;
-    constructor(child, complete, context) {
-        this.complete = complete;
-        this.context = context;
-        child.once("exit", (code) => {
-            this.exited = true;
-            this.exitCode = code;
-            this.timer = setTimeout(() => {
-                destroySpawnedChildStreams(child);
-                this.finish();
-            }, EXIT_STDIO_GRACE_MS);
-            this.timer.unref();
-        });
-        child.once("close", (code) => {
-            this.finish(code);
-        });
-    }
-    finish(closeCode) {
-        if (this.completed) {
-            return;
-        }
-        this.completed = true;
-        this.clear();
-        const context = this.context();
-        this.complete(resolveSpawnedChildExitCode({
-            closeCode,
-            exitCode: this.exitCode,
-            useExitFallback: this.exited,
-            timedOut: context.timedOut,
-            spawnError: context.spawnError,
-        }));
-    }
-    clear() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = undefined;
-        }
-    }
-}
-class BrowserChild {
-    options;
-    resolve;
-    aborted = false;
-    agentBrowserStarted = false;
-    settled = false;
-    spawnError;
-    stderr = "";
-    stdout = new ProcessStdout();
-    pendingTermination;
-    killTimer;
-    timeoutTimer;
-    abortListener;
-    timedOut = false;
-    completion;
-    child;
-    constructor(options, resolve) {
-        this.options = options;
-        this.resolve = resolve;
-        const spawnBrowser = processPlatform === "win32" &&
-            (options.stockLauncher === undefined || options.stockLauncher.length === 0)
-            ? crossSpawn
-            : spawn;
-        this.child = spawnBrowser(options.stockLauncher ?? "agent-browser", options.args, {
-            cwd: options.cwd,
-            env: options.env,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-    }
-    start() {
-        this.observe();
-        this.watchBudget();
-        this.writeStdin();
-    }
-    started() {
-        this.agentBrowserStarted = true;
-        this.options.onStarted();
-    }
-    observe() {
-        const child = this.child;
-        if (processPlatform !== "win32") {
-            child.once("spawn", () => {
-                this.started();
-            });
-        }
-        child.stdin.on("error", (error) => {
-            this.recordStdinError(error);
-        });
-        child.once("error", (error) => {
-            this.spawnError = error;
-            this.finish(resolveSpawnedChildExitCode({
-                useExitFallback: false,
-                timedOut: this.timedOut,
-                spawnError: this.spawnError,
-            }));
-        });
-        this.completion = new ChildCompletion(child, (code) => {
-            this.finish(code);
-        }, () => ({ timedOut: this.timedOut, spawnError: this.spawnError }));
-        child.stdout.on("data", (chunk) => {
-            this.stdout.queue(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        });
-        child.stderr.on("data", (chunk) => {
-            this.stderr = appendProcessOutputTail(this.stderr, chunk.toString(), MAX_BUFFERED_STDERR_CHARS);
-        });
-    }
-    watchBudget() {
-        if (this.options.timeoutMs > 0) {
-            this.timeoutTimer = setTimeout(() => {
-                this.terminate("timeout");
-            }, this.options.timeoutMs);
-            this.timeoutTimer.unref();
-        }
-        const signal = this.options.signal;
-        if (signal) {
-            this.abortListener = () => {
-                this.terminate(this.options.deadlineExpired() ? "timeout" : "abort");
-            };
-            signal.addEventListener("abort", this.abortListener, { once: true });
-            if (signal.aborted) {
-                this.abortListener();
-            }
-        }
-    }
-    terminate(reason) {
-        if (this.settled) {
-            return;
-        }
-        if (reason === "abort") {
-            this.aborted = true;
-        }
-        else {
-            this.timedOut = true;
-        }
-        if (this.pendingTermination) {
-            return;
-        }
-        this.pendingTermination = terminateSpawnedChild(this.child, "SIGTERM");
-        // Windows taskkill already forces the tree; don't remove its root concurrently.
-        if (processPlatform !== "win32") {
-            this.killTimer = setTimeout(() => {
-                this.pendingTermination = terminateSpawnedChild(this.child, "SIGKILL");
-            }, 2_000);
-        }
-    }
-    recordStdinError(error) {
-        const stdinError = normalizeProcessError(error);
-        const code = getErrorCode(stdinError);
-        if (code === "EPIPE" || code === "EOF" || code === "ERR_STREAM_DESTROYED") {
-            return;
-        }
-        this.spawnError ??= stdinError;
-    }
-    writeStdin() {
-        if (this.aborted || this.options.signal?.aborted === true) {
-            this.child.stdin.destroy();
-            return;
-        }
-        try {
-            if (this.options.stdin !== undefined && this.options.stdin.length > 0) {
-                this.child.stdin.write(this.options.stdin);
-            }
-            this.child.stdin.end();
-        }
-        catch (error) {
-            this.recordStdinError(error);
-            this.child.stdin.destroy();
-        }
-    }
-    finish(exitCode) {
-        if (this.settled) {
-            return;
-        }
-        this.settled = true;
-        if (this.abortListener) {
-            this.options.signal?.removeEventListener("abort", this.abortListener);
-            this.abortListener = undefined;
-        }
-        if (this.killTimer) {
-            clearTimeout(this.killTimer);
-        }
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-        }
-        this.completion?.clear();
-        // The completion path owns spill/termination rejection and always settles the outer operation.
-        this.collectResult(exitCode)
-            .then(this.resolve)
-            .catch((error) => {
-            this.spawnError ??= normalizeProcessError(error);
-            destroySpawnedChildStreams(this.child);
-            this.resolve(this.result(exitCode, ""));
-        });
-    }
-    async collectResult(exitCode) {
-        await this.stdout.drain();
-        await this.pendingTermination;
-        const output = await this.stdout.finish();
-        if (processPlatform === "win32" && !this.spawnError) {
-            this.started();
-        }
-        this.spawnError ??= output.error;
-        destroySpawnedChildStreams(this.child);
-        return this.result(exitCode, output.stdout, output.stdoutSpillPath);
-    }
-    result(exitCode, stdout, stdoutSpillPath) {
-        return {
-            aborted: this.aborted,
-            agentBrowserStarted: this.agentBrowserStarted,
-            exitCode,
-            spawnError: this.spawnError,
-            stderr: this.stderr,
-            stdout,
-            stdoutSpillPath,
-            timedOut: this.timedOut,
-            timeoutMs: this.timedOut ? this.options.timeoutMs : undefined,
-        };
-    }
-}
-export function runBrowserChild(options) {
-    return new Promise((resolve) => {
-        const error = options.policyError();
-        if (error !== undefined && error.length > 0) {
-            resolve({
-                aborted: false,
-                agentBrowserStarted: false,
-                exitCode: 1,
-                spawnError: new Error(error),
-                stderr: "",
-                stdout: "",
-                timedOut: false,
-            });
-            return;
-        }
-        const child = new BrowserChild(options, resolve);
-        child.start();
-    });
-}

package/dist/extensions/agent-browser/lib/process-environment.js

@@ -1,48 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { rm } from "node:fs/promises";
-import { getBooleanFlagValue } from "./argv-grammar.js";
-import { writeSecureTempFile } from "./temp.js";
-const isolatedAgentBrowserEnvironment = new AsyncLocalStorage();
-const agentBrowserProcessEnvironment = new AsyncLocalStorage();
-const PROXY_ENV_NAMES = new Set(["ALL_PROXY", "HTTPS_PROXY", "HTTP_PROXY", "NO_PROXY"]);
-export function getAgentBrowserProcessEnvironment(baseEnv = process.env) {
-    const isolatedConfig = isolatedAgentBrowserEnvironment.getStore();
-    if (isolatedConfig === undefined) {
-        return { ...baseEnv, ...agentBrowserProcessEnvironment.getStore()?.env };
-    }
-    return {
-        ...Object.fromEntries(Object.entries(baseEnv).filter(([name]) => {
-            const normalizedName = name.toUpperCase();
-            return !normalizedName.startsWith("AGENT_BROWSER_") && !PROXY_ENV_NAMES.has(normalizedName);
-        })),
-        AGENT_BROWSER_CONFIG: isolatedConfig,
-    };
-}
-export function getAgentBrowserProcessArgs(args) {
-    if (isolatedAgentBrowserEnvironment.getStore() !== undefined) {
-        return [...args];
-    }
-    const overrides = agentBrowserProcessEnvironment.getStore()?.booleanArgs ?? [];
-    const missing = overrides.flatMap(([flag, value]) => getBooleanFlagValue(args, flag) === undefined ? [flag, value] : []);
-    return missing.length > 0 ? [...missing, ...args] : [...args];
-}
-export function withAgentBrowserProcessEnvironment(env, run, booleanArgs) {
-    const parent = agentBrowserProcessEnvironment.getStore();
-    return agentBrowserProcessEnvironment.run({ env: { ...parent?.env, ...env }, booleanArgs: booleanArgs ?? parent?.booleanArgs ?? [] }, run);
-}
-export async function withIsolatedAgentBrowserEnvironment(run) {
-    if (isolatedAgentBrowserEnvironment.getStore() !== undefined) {
-        return await run();
-    }
-    const path = await writeSecureTempFile({
-        content: "{}",
-        prefix: "script-config",
-        suffix: ".json",
-    });
-    try {
-        return await isolatedAgentBrowserEnvironment.run(path, run);
-    }
-    finally {
-        await rm(path, { force: true });
-    }
-}

package/dist/extensions/agent-browser/lib/process-errors.js

@@ -1,23 +0,0 @@
-import { inspect } from "node:util";
-import { isRecord } from "./parsing.js";
-/** Read native errno evidence without asserting that an arbitrary caught value is an Error. */
-export function normalizeProcessError(error) {
-    if (error instanceof Error) {
-        return error;
-    }
-    if (typeof error === "string") {
-        return new Error(error);
-    }
-    if (typeof error === "number" ||
-        typeof error === "boolean" ||
-        typeof error === "bigint" ||
-        typeof error === "symbol" ||
-        error === undefined ||
-        error === null) {
-        return new Error(String(error));
-    }
-    return new Error(inspect(error));
-}
-export function getErrorCode(error) {
-    return isRecord(error) && typeof error.code === "string" ? error.code : undefined;
-}

package/dist/extensions/agent-browser/lib/process-identity.js

@@ -1,127 +0,0 @@
-import { execFile } from "node:child_process";
-import { dirname, join, win32 } from "node:path";
-export function getCurrentProcessUid() {
-    return typeof process.getuid === "function" ? process.getuid() : undefined;
-}
-const WINDOWS_PROCESS_START_IDENTITY_PREFIX = "win32-powershell-ticks-v1:";
-// Native Windows PowerShell startup can exhaust the former five-second probe budget.
-const PROCESS_START_IDENTITY_TIMEOUT_MS = process.platform === "win32" ? 10_000 : 5_000;
-const DEFAULT_WINDOWS_SYSTEM_ROOT = "C:\\Windows";
-export function buildProcessStartIdentityCommand(pid, platform = process.platform) {
-    if (!Number.isSafeInteger(pid) || pid <= 0) {
-        return undefined;
-    }
-    const configuredSystemRoot = process.env.SystemRoot;
-    const windowsSystemRoot = configuredSystemRoot !== undefined &&
-        configuredSystemRoot.length > 0 &&
-        win32.isAbsolute(configuredSystemRoot)
-        ? configuredSystemRoot
-        : DEFAULT_WINDOWS_SYSTEM_ROOT;
-    return platform === "win32"
-        ? {
-            args: [
-                "-NoProfile",
-                "-NonInteractive",
-                "-Command",
-                `$p = Get-Process -Id ${pid} -ErrorAction Stop; Write-Output ("${WINDOWS_PROCESS_START_IDENTITY_PREFIX}" + $p.StartTime.ToUniversalTime().Ticks)`,
-            ],
-            file: win32.join(windowsSystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
-        }
-        : {
-            args: ["-p", String(pid), "-o", "lstart="],
-            file: platform === "android" ? join(dirname(process.execPath), "ps") : "/bin/ps",
-        };
-}
-export function buildProcessStartIdentityCommands(pid, platform = process.platform) {
-    const primary = buildProcessStartIdentityCommand(pid, platform);
-    if (!primary) {
-        return [];
-    }
-    return platform === "win32"
-        ? [primary]
-        : [
-            primary,
-            ...(platform === "android"
-                ? [
-                    { ...primary, file: "/bin/ps" },
-                    { ...primary, file: "/usr/bin/ps" },
-                ]
-                : [
-                    { ...primary, file: "/usr/bin/ps" },
-                    { ...primary, file: "ps" },
-                ]),
-        ];
-}
-export function normalizeProcessStartIdentity(stdout) {
-    const trimmed = stdout.trim();
-    if (trimmed.length === 0 || trimmed.includes("\0") || /[\r\n]/.test(trimmed)) {
-        return undefined;
-    }
-    return trimmed.replace(/\s+/g, " ");
-}
-let currentProcessStartIdentityPromise;
-let currentProcessStartIdentity;
-async function executeProcessStartIdentityCommand(command, budget = {}) {
-    if (budget.signal?.aborted === true ||
-        (budget.deadline !== undefined && Date.now() >= budget.deadline)) {
-        return undefined;
-    }
-    const timeout = Math.max(1, Math.min(PROCESS_START_IDENTITY_TIMEOUT_MS, (budget.deadline ?? Infinity) - Date.now()));
-    return await new Promise((resolve) => {
-        execFile(command.file, command.args, { timeout, signal: budget.signal }, (error, stdout) => {
-            resolve(error ? undefined : normalizeProcessStartIdentity(stdout));
-        });
-    });
-}
-export async function resolveProcessStartIdentityFromCommands(commands, execute = executeProcessStartIdentityCommand) {
-    for (const command of commands) {
-        // Fallback commands run only after the prior identity probe has failed.
-        // oxlint-disable-next-line no-await-in-loop
-        const identity = await execute(command);
-        if (identity !== undefined && identity.length > 0) {
-            return identity;
-        }
-    }
-    return undefined;
-}
-async function readUncachedProcessStartIdentity(pid, platform, budget) {
-    return await resolveProcessStartIdentityFromCommands(buildProcessStartIdentityCommands(pid, platform), (command) => executeProcessStartIdentityCommand(command, budget));
-}
-function identityBudgetExpired(budget) {
-    return (budget?.signal?.aborted === true ||
-        (budget?.deadline !== undefined && Date.now() >= budget.deadline));
-}
-export async function readProcessStartIdentity(pid, platform = process.platform, budget) {
-    if (identityBudgetExpired(budget)) {
-        return undefined;
-    }
-    if (pid !== process.pid || platform !== process.platform) {
-        return await readUncachedProcessStartIdentity(pid, platform, budget);
-    }
-    if (currentProcessStartIdentity !== undefined && currentProcessStartIdentity.length > 0) {
-        return currentProcessStartIdentity;
-    }
-    if (budget) {
-        const identity = await readUncachedProcessStartIdentity(pid, platform, budget);
-        if (identity !== undefined && identity.length > 0) {
-            currentProcessStartIdentity = identity;
-        }
-        return identity;
-    }
-    return await readCachedProcessStartIdentity(pid, platform);
-}
-async function readCachedProcessStartIdentity(pid, platform) {
-    currentProcessStartIdentityPromise ??= readUncachedProcessStartIdentity(pid, platform).then((identity) => {
-        if (identity === undefined || identity.length === 0) {
-            currentProcessStartIdentityPromise = undefined;
-        }
-        else {
-            currentProcessStartIdentity = identity;
-        }
-        return identity;
-    });
-    return await currentProcessStartIdentityPromise;
-}
-export function processStartIdentitiesMatch(recorded, current) {
-    return recorded === current;
-}