pi-agent-browser-native 0.9.5 → 0.9.7

package/dist/extensions/agent-browser/lib/electron/discovery.js

@@ -1,217 +0,0 @@
-import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
-import { discoverDarwinApps, inspectDarwinApp } from "./discovery-darwin.js";
-import { hasLinuxElectronEvidence, inspectWin32Executable, resolveRealPath, } from "./discovery-evidence.js";
-import { discoverLinuxApps } from "./discovery-linux.js";
-import { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS, } from "./discovery-types.js";
-export { inspectDarwinApp } from "./discovery-darwin.js";
-export { hasLinuxElectronEvidence } from "./discovery-evidence.js";
-export { ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS, ELECTRON_DISCOVERY_MAX_RESULTS, } from "./discovery-types.js";
-const SENSITIVE_APP_PATTERNS = [
-    { category: "notes", patterns: [/\bobsidian\b/i, /\bnotion\b/i, /\blogseq\b/i] },
-    {
-        category: "chat",
-        patterns: [
-            /\bslack\b/i,
-            /\bdiscord\b/i,
-            /\bteams\b/i,
-            /\bsignal\b/i,
-            /\btelegram\b/i,
-            /\bwhatsapp\b/i,
-        ],
-    },
-    {
-        category: "mail",
-        patterns: [
-            /\bmail\b/i,
-            /\boutlook\b/i,
-            /\bthunderbird\b/i,
-            /\bspark\b/i,
-            /\bproton[- ]?mail\b/i,
-        ],
-    },
-    {
-        category: "developer-workspace",
-        patterns: [
-            /\bvisual studio code\b/i,
-            /\bvs ?code\b/i,
-            /\bcode - insiders\b/i,
-            /^code$/i,
-            /\bcursor\b/i,
-            /\bwindsurf\b/i,
-        ],
-    },
-    {
-        category: "passwords-auth",
-        patterns: [
-            /\b1password\b/i,
-            /\bbitwarden\b/i,
-            /\blastpass\b/i,
-            /\bdashlane\b/i,
-            /\bauthy\b/i,
-            /\bauthenticator\b/i,
-            /\bkeepass\b/i,
-        ],
-    },
-];
-function normalizeSensitivityValue(value) {
-    const normalized = value
-        ?.trim()
-        .replace(/[_./\\-]+/g, " ")
-        .replace(/\s+/g, " ");
-    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
-}
-export function getElectronAppSensitivity(app) {
-    const values = [app.name, app.bundleId, app.desktopId, app.appPath, app.executablePath]
-        .map(normalizeSensitivityValue)
-        .filter((value) => value !== undefined);
-    const categories = SENSITIVE_APP_PATTERNS.filter(({ patterns }) => values.some((value) => patterns.some((pattern) => pattern.test(value)))).map(({ category }) => category);
-    if (categories.length === 0) {
-        return undefined;
-    }
-    return {
-        categories: [...new Set(categories)].sort((left, right) => {
-            if (left === right) {
-                return 0;
-            }
-            return left < right ? -1 : 1;
-        }),
-        level: "likely-sensitive",
-        reason: "App name, bundle id, desktop id, or path matched common private-data app patterns; discovery still does not enforce policy.",
-    };
-}
-function annotateElectronAppSensitivity(app) {
-    const sensitivity = getElectronAppSensitivity(app);
-    return sensitivity ? { ...app, sensitivity } : app;
-}
-function normalizeMaxResults(value) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        return ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS;
-    }
-    return Math.min(value, ELECTRON_DISCOVERY_MAX_RESULTS);
-}
-function linuxDesktopDirectories(locations, homeDir) {
-    return (locations?.linuxDesktopDirectories ?? [
-        join(homeDir, ".local", "share", "applications"),
-        "/usr/share/applications",
-        "/var/lib/snapd/desktop/applications",
-        join(homeDir, ".local", "share", "flatpak", "exports", "share", "applications"),
-        "/var/lib/flatpak/exports/share/applications",
-    ]);
-}
-function resolvePackageLocations(locations, homeDir) {
-    return {
-        flatpakSystemAppDirectory: locations?.flatpakSystemAppDirectory ?? "/var/lib/flatpak/app",
-        flatpakUserAppDirectory: locations?.flatpakUserAppDirectory ?? join(homeDir, ".local", "share", "flatpak", "app"),
-        snapBinDirectory: locations?.snapBinDirectory ?? "/snap/bin",
-        snapMountDirectory: locations?.snapMountDirectory ?? "/snap",
-    };
-}
-function resolveLocations(locations) {
-    const homeDir = locations?.homeDir ?? homedir();
-    return {
-        ...resolvePackageLocations(locations, homeDir),
-        homeDir,
-        darwinApplicationDirectories: locations?.darwinApplicationDirectories ?? [
-            "/Applications",
-            join(homeDir, "Applications"),
-        ],
-        linuxDesktopDirectories: linuxDesktopDirectories(locations, homeDir),
-        pathEnv: locations?.pathEnv ?? process.env.PATH ?? "",
-    };
-}
-function appMatchesQuery(app, query) {
-    if (query === undefined || query.length === 0) {
-        return true;
-    }
-    const normalized = query.toLowerCase();
-    return [
-        app.name,
-        app.bundleId,
-        app.appPath,
-        app.executablePath,
-        app.comment,
-        app.desktopId,
-        app.icon,
-        app.packageSource,
-    ]
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .some((value) => value.toLowerCase().includes(normalized));
-}
-function dedupeApps(apps) {
-    const seen = new Set();
-    return apps.filter((app) => {
-        const key = app.appPath ?? app.executablePath;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-function sortApps(apps) {
-    return [...apps].sort((left, right) => {
-        const comparison = left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
-        return comparison === 0 ? left.executablePath.localeCompare(right.executablePath) : comparison;
-    });
-}
-function findMacAppBundleAncestor(path) {
-    const parts = resolve(path).split(/[\\/]+/);
-    const index = parts.findIndex((part) => part.endsWith(".app"));
-    if (index < 0) {
-        return undefined;
-    }
-    const ancestor = parts.slice(0, index + 1).join("/");
-    return ancestor.length > 0 ? ancestor : "/";
-}
-export async function inspectElectronExecutablePath(executablePath, platform = process.platform) {
-    const resolved = await resolveRealPath(executablePath);
-    if (platform === "darwin") {
-        const appPath = findMacAppBundleAncestor(resolved);
-        return appPath === undefined ? undefined : inspectDarwinApp(appPath);
-    }
-    if (platform === "linux") {
-        if (!(await hasLinuxElectronEvidence(resolved))) {
-            return undefined;
-        }
-        return { executablePath: resolved, name: basename(resolved), platform: "linux" };
-    }
-    if (platform === "win32") {
-        return inspectWin32Executable(resolved);
-    }
-    return undefined;
-}
-export async function inspectElectronAppPath(appPath, platform = process.platform) {
-    if (platform === "darwin" || appPath.endsWith(".app")) {
-        return inspectDarwinApp(appPath);
-    }
-    return inspectElectronExecutablePath(appPath, platform);
-}
-export async function discoverElectronApps(options = {}) {
-    const platform = options.platform ?? process.platform;
-    const query = normalizeDiscoveryQuery(options.query);
-    const maxResults = normalizeMaxResults(options.maxResults);
-    const locations = resolveLocations(options.locations);
-    if (platform !== "darwin" && platform !== "linux") {
-        return { apps: [], maxResults, omittedCount: 0, platform: "unsupported", query };
-    }
-    const discovered = platform === "darwin"
-        ? await discoverDarwinApps(locations.darwinApplicationDirectories)
-        : await discoverLinuxApps(locations);
-    const filtered = sortApps(dedupeApps(discovered.apps
-        .map(annotateElectronAppSensitivity)
-        .filter((app) => appMatchesQuery(app, query))));
-    const apps = filtered.slice(0, maxResults);
-    return {
-        apps,
-        maxResults,
-        omittedCount: Math.max(0, filtered.length - apps.length),
-        platform,
-        query,
-        skippedCount: discovered.skippedCount === 0 ? undefined : discovered.skippedCount,
-    };
-}
-function normalizeDiscoveryQuery(value) {
-    const query = value?.trim();
-    return query === undefined || query.length === 0 ? undefined : query;
-}

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

@@ -1,102 +0,0 @@
-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

@@ -1,209 +0,0 @@
-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

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