pi-agent-browser-native 0.9.2 → 0.9.4

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

@@ -0,0 +1,284 @@
+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,13 +1,15 @@
 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() };
+    if (isolatedConfig === undefined) {
+        return { ...baseEnv, ...agentBrowserProcessEnvironment.getStore()?.env };
+    }
     return {
         ...Object.fromEntries(Object.entries(baseEnv).filter(([name]) => {
             const normalizedName = name.toUpperCase();
@@ -16,13 +18,27 @@ export function getAgentBrowserProcessEnvironment(baseEnv = process.env) {
         AGENT_BROWSER_CONFIG: isolatedConfig,
     };
 }
-export function withAgentBrowserProcessEnvironment(env, run) {
-    return agentBrowserProcessEnvironment.run({ ...agentBrowserProcessEnvironment.getStore(), ...env }, run);
+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)
+    if (isolatedAgentBrowserEnvironment.getStore() !== undefined) {
         return await run();
-    const path = await writeSecureTempFile({ content: "{}", prefix: "script-config", suffix: ".json" });
+    }
+    const path = await writeSecureTempFile({
+        content: "{}",
+        prefix: "script-config",
+        suffix: ".json",
+    });
     try {
         return await isolatedAgentBrowserEnvironment.run(path, run);
     }

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

@@ -0,0 +1,23 @@
+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,14 +1,20 @@
 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)
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
         return undefined;
+    }
     const configuredSystemRoot = process.env.SystemRoot;
-    const windowsSystemRoot = configuredSystemRoot && win32.isAbsolute(configuredSystemRoot)
+    const windowsSystemRoot = configuredSystemRoot !== undefined &&
+        configuredSystemRoot.length > 0 &&
+        win32.isAbsolute(configuredSystemRoot)
         ? configuredSystemRoot
         : DEFAULT_WINDOWS_SYSTEM_ROOT;
     return platform === "win32"
@@ -28,28 +34,38 @@ export function buildProcessStartIdentityCommand(pid, platform = process.platfor
 }
 export function buildProcessStartIdentityCommands(pid, platform = process.platform) {
     const primary = buildProcessStartIdentityCommand(pid, platform);
-    if (!primary)
+    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" }]),
+                ? [
+                    { ...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 || trimmed.includes("\0") || /[\r\n]/.test(trimmed))
+    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 || (budget.deadline !== undefined && Date.now() >= budget.deadline))
+    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) => {
@@ -59,33 +75,49 @@ async function executeProcessStartIdentityCommand(command, budget = {}) {
 }
 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)
+        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));
+    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 (budget?.signal?.aborted || (budget?.deadline !== undefined && Date.now() >= budget.deadline))
+    if (identityBudgetExpired(budget)) {
         return undefined;
-    if (pid !== process.pid || platform !== process.platform)
+    }
+    if (pid !== process.pid || platform !== process.platform) {
         return await readUncachedProcessStartIdentity(pid, platform, budget);
-    if (currentProcessStartIdentity)
+    }
+    if (currentProcessStartIdentity !== undefined && currentProcessStartIdentity.length > 0) {
         return currentProcessStartIdentity;
+    }
     if (budget) {
         const identity = await readUncachedProcessStartIdentity(pid, platform, budget);
-        if (identity)
+        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)
+        if (identity === undefined || identity.length === 0) {
             currentProcessStartIdentityPromise = undefined;
-        else
+        }
+        else {
             currentProcessStartIdentity = identity;
+        }
         return identity;
     });
     return await currentProcessStartIdentityPromise;