pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/electron/launch-monitor.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { fetchCdpJson, parseCdpTargets, parseCdpVersion, } from "./cdp.js";
+import { isRecord } from "../parsing.js";
+import { stringifyUnknown } from "../results/text.js";
+const POLL_INTERVAL_MS = 100;
+// Re-read native cancellation after each await; TypeScript cannot model external AbortSignal writers.
+export function isElectronLaunchAborted(signal) {
+    return signal?.aborted ?? false;
+}
+export function waitForElectronPoll(ms, signal) {
+    if (isElectronLaunchAborted(signal)) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", done);
+            resolve();
+        }
+        signal?.addEventListener("abort", done, { once: true });
+    });
+}
+function activePortReadError(error) {
+    const code = isRecord(error) && typeof error.code === "string" ? error.code : undefined;
+    return code !== undefined && code.length > 0 && code !== "ENOENT"
+        ? `${code}: ${error instanceof Error ? error.message : stringifyUnknown(error)}`
+        : undefined;
+}
+async function readDevToolsActivePort(userDataDir) {
+    const path = `${userDataDir}/DevToolsActivePort`;
+    try {
+        const text = await readFile(path, "utf8");
+        const port = Number(text.split(/\r?\n/)[0].trim());
+        const valid = Number.isSafeInteger(port) && port > 0 && port <= 65_535;
+        return {
+            found: true,
+            path,
+            port: valid ? port : undefined,
+            ...(valid ? {} : { error: "DevToolsActivePort did not contain a valid TCP port." }),
+        };
+    }
+    catch (error) {
+        return { error: activePortReadError(error), found: false, path };
+    }
+}
+export async function pollDevToolsActivePort(options) {
+    let devToolsActivePort;
+    while (Date.now() <= options.deadlineMs) {
+        if (isElectronLaunchAborted(options.signal)) {
+            return { devToolsActivePort, failure: "aborted" };
+        }
+        const spawnError = options.getSpawnError();
+        if (spawnError !== undefined) {
+            return { devToolsActivePort, failure: "spawn-error", spawnError };
+        }
+        // A newly written port file is observed between sleeps, within one launch deadline.
+        // oxlint-disable-next-line no-await-in-loop
+        devToolsActivePort = await readDevToolsActivePort(options.userDataDir);
+        if (devToolsActivePort.port !== undefined) {
+            return { devToolsActivePort, port: devToolsActivePort.port };
+        }
+        const exit = options.getChildExit();
+        if (exit.code !== null || exit.signal !== null) {
+            return {
+                devToolsActivePort,
+                failure: exit.code === 0 ? "single-instance-conflict" : "spawn-error",
+            };
+        }
+        // Keep the next file observation after the polling delay; concurrent polls would race cleanup.
+        // oxlint-disable-next-line no-await-in-loop
+        await waitForElectronPoll(POLL_INTERVAL_MS, options.signal);
+    }
+    return { devToolsActivePort, failure: "timeout" };
+}
+export async function pollCdpMetadata(port, deadlineMs, signal) {
+    while (Date.now() <= deadlineMs) {
+        if (isElectronLaunchAborted(signal)) {
+            return { aborted: true };
+        }
+        // CDP readiness must be observed before targets can be read, within the same deadline.
+        // oxlint-disable-next-line no-await-in-loop
+        const versionData = await fetchCdpJson(`http://127.0.0.1:${port}/json/version`, signal);
+        const version = parseCdpVersion(versionData);
+        if (isElectronLaunchAborted(signal)) {
+            return { aborted: true };
+        }
+        if (version !== undefined) {
+            // Read targets only after version proves readiness; cancellation still wins after this await.
+            // oxlint-disable-next-line no-await-in-loop
+            const targetsData = await fetchCdpJson(`http://127.0.0.1:${port}/json/list`, signal);
+            const targets = parseCdpTargets(targetsData);
+            return isElectronLaunchAborted(signal)
+                ? { aborted: true }
+                : { aborted: false, metadata: { targets, version } };
+        }
+        // Each failed readiness probe waits before the next attempt.
+        // oxlint-disable-next-line no-await-in-loop
+        await waitForElectronPoll(POLL_INTERVAL_MS, signal);
+    }
+    return { aborted: false };
+}

package/dist/extensions/agent-browser/lib/electron/launch-process.js

@@ -0,0 +1,209 @@
+import { spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isRecord } from "../parsing.js";
+import { stringifyUnknown } from "../results/text.js";
+import { waitForElectronPoll } from "./launch-monitor.js";
+// ponytail: bound failure reads, not lifetime log growth; noisy long-lived apps need rotation if observed.
+const OUTPUT_TAIL_BYTES = 4096;
+async function closeOutputHandle(file) {
+    try {
+        await file.close();
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : stringifyUnknown(error);
+    }
+}
+async function readOutputTail(path) {
+    let file;
+    let result;
+    try {
+        file = await open(path, "r");
+        const { size } = await file.stat();
+        const buffer = Buffer.alloc(Math.min(size, OUTPUT_TAIL_BYTES));
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, Math.max(0, size - buffer.length));
+        result = {
+            tail: buffer.subarray(0, bytesRead).toString("utf8"),
+            truncated: size > buffer.length,
+        };
+    }
+    catch (error) {
+        result = { error: error instanceof Error ? error.message : stringifyUnknown(error) };
+    }
+    if (file !== undefined) {
+        const closeError = await closeOutputHandle(file);
+        if (closeError !== undefined) {
+            result = {
+                ...result,
+                error: [result.error, `Output reader close failed: ${closeError}`]
+                    .filter((entry) => entry !== undefined && entry.length > 0)
+                    .join("; "),
+            };
+        }
+    }
+    return result;
+}
+function streamLines(stream, capture) {
+    const lines = [];
+    if (capture.tail !== undefined) {
+        const truncated = capture.truncated === true ? ` (last ${OUTPUT_TAIL_BYTES} bytes)` : "";
+        lines.push(`App ${stream}${truncated}: ${capture.tail.length > 0 ? capture.tail : "(empty)"}`);
+    }
+    if (capture.error !== undefined && capture.error.length > 0) {
+        lines.push(`App ${stream} capture error: ${capture.error}`);
+    }
+    return lines;
+}
+/** Owns child listeners and file handles from spawn through failed-launch termination. */
+export class ElectronLaunchProcess {
+    userDataDir;
+    process;
+    spawnFailure;
+    exitedCode = null;
+    exitedSignal = null;
+    capturedOutput = false;
+    outputCloseError;
+    constructor(userDataDir) {
+        this.userDataDir = userDataDir;
+    }
+    get child() {
+        return this.process;
+    }
+    get spawnError() {
+        return this.spawnFailure;
+    }
+    get exitCode() {
+        return this.exitedCode;
+    }
+    get exitSignal() {
+        return this.exitedSignal;
+    }
+    get outputCaptured() {
+        return this.capturedOutput;
+    }
+    get cleanupError() {
+        return this.outputCloseError;
+    }
+    childExit = () => ({ code: this.exitedCode, signal: this.exitedSignal });
+    childSpawnError = () => this.spawnFailure;
+    onError = (error) => {
+        this.spawnFailure = error;
+    };
+    onExit = (code, signal) => {
+        this.exitedCode = code;
+        this.exitedSignal = signal;
+    };
+    async spawn(executablePath, args, signal) {
+        const handles = [];
+        try {
+            // Open in native stdout/stderr order; a partial open still owns its first handle.
+            handles.push(await open(join(this.userDataDir, "stdout.log"), "wx", 0o600));
+            handles.push(await open(join(this.userDataDir, "stderr.log"), "wx", 0o600));
+            signal?.throwIfAborted();
+            this.process = spawn(executablePath, args, {
+                cwd: dirname(executablePath),
+                detached: process.platform !== "win32",
+                stdio: ["ignore", handles[0].fd, handles[1].fd],
+            });
+            this.capturedOutput = true;
+            this.process.once("error", this.onError);
+            this.process.once("exit", this.onExit);
+            this.process.unref();
+        }
+        catch (error) {
+            this.spawnFailure = error instanceof Error ? error : new Error(stringifyUnknown(error));
+        }
+        finally {
+            const errors = await Promise.all(handles.map(closeOutputHandle));
+            const messages = errors
+                .filter((error) => error !== undefined)
+                .map((error) => `Output handle close failed: ${error}`);
+            this.outputCloseError = messages.length > 0 ? messages.join("; ") : undefined;
+        }
+    }
+    pidAlive() {
+        const child = this.process;
+        if (child?.pid === undefined || child.pid === 0) {
+            return undefined;
+        }
+        if (child.exitCode !== null || child.signalCode !== null) {
+            return false;
+        }
+        try {
+            process.kill(child.pid, 0);
+            return true;
+        }
+        catch (error) {
+            return isRecord(error) && error.code === "EPERM";
+        }
+    }
+    async waitForExit(deadlineMs) {
+        const child = this.process;
+        if (child === undefined) {
+            return true;
+        }
+        while (Date.now() <= deadlineMs) {
+            if (child.exitCode !== null || child.signalCode !== null) {
+                return true;
+            }
+            // Observe exit between sleeps; simultaneous waits cannot establish the grace window.
+            // oxlint-disable-next-line no-await-in-loop
+            await waitForElectronPoll(50);
+        }
+        return child.exitCode !== null || child.signalCode !== null;
+    }
+    signalChild(signal) {
+        try {
+            this.process?.kill(signal);
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : stringifyUnknown(error);
+        }
+    }
+    async terminate() {
+        const child = this.process;
+        if (child?.pid === undefined ||
+            child.pid === 0 ||
+            child.exitCode !== null ||
+            child.signalCode !== null) {
+            return undefined;
+        }
+        const terminateError = this.signalChild("SIGTERM");
+        if (terminateError !== undefined) {
+            return terminateError;
+        }
+        if (await this.waitForExit(Date.now() + 1_000)) {
+            return undefined;
+        }
+        const killError = this.signalChild("SIGKILL");
+        if (killError !== undefined) {
+            return killError;
+        }
+        if (await this.waitForExit(Date.now() + 1_000)) {
+            return undefined;
+        }
+        return `PID ${child.pid} remained alive after failed Electron launch cleanup.`;
+    }
+    async readOutput() {
+        if (!this.capturedOutput) {
+            return { evidence: {}, lines: [] };
+        }
+        const [stdout, stderr] = await Promise.all([
+            readOutputTail(join(this.userDataDir, "stdout.log")),
+            readOutputTail(join(this.userDataDir, "stderr.log")),
+        ]);
+        return {
+            evidence: {
+                stdoutTail: stdout.tail,
+                stdoutTruncated: stdout.truncated,
+                stdoutError: stdout.error,
+                stderrTail: stderr.tail,
+                stderrTruncated: stderr.truncated,
+                stderrError: stderr.error,
+            },
+            lines: [...streamLines("stdout", stdout), ...streamLines("stderr", stderr)],
+        };
+    }
+}

package/dist/extensions/agent-browser/lib/electron/launch-types.js

@@ -0,0 +1,2 @@
+export const ELECTRON_LAUNCH_RECORD_VERSION = 1;
+export const ELECTRON_PROFILE_DIR_PREFIX = "electron-profile-";