pi-agent-browser-native 0.9.5 → 0.9.7

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

@@ -1,109 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import { basename, join } from "node:path";
-import { pathExists } from "../fs-utils.js";
-import { hasElectronAppPayload, isDirectory } from "./discovery-evidence.js";
-function readPlistString(plist, key) {
-    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const match = new RegExp(`<key>\\s*${escapedKey}\\s*</key>\\s*<string>([\\s\\S]*?)</string>`, "i").exec(plist);
-    return match?.[1]
-        ?.trim()
-        .replaceAll("&amp;", "&")
-        .replaceAll("&lt;", "<")
-        .replaceAll("&gt;", ">")
-        .replaceAll("&quot;", '"')
-        .replaceAll("&apos;", "'");
-}
-async function readMacInfoPlist(appPath) {
-    try {
-        const plist = await readFile(join(appPath, "Contents", "Info.plist"), "utf8");
-        return {
-            CFBundleDisplayName: readPlistString(plist, "CFBundleDisplayName") ?? "",
-            CFBundleExecutable: readPlistString(plist, "CFBundleExecutable") ?? "",
-            CFBundleIdentifier: readPlistString(plist, "CFBundleIdentifier") ?? "",
-            CFBundleName: readPlistString(plist, "CFBundleName") ?? "",
-        };
-    }
-    catch {
-        return {};
-    }
-}
-async function resolveMacExecutablePath(appPath, executableName, fallbackName) {
-    const directory = join(appPath, "Contents", "MacOS");
-    if (executableName !== undefined && executableName.trim().length > 0) {
-        const path = join(directory, executableName);
-        return (await pathExists(path)) ? path : undefined;
-    }
-    try {
-        const entries = await readdir(directory, { withFileTypes: true });
-        const candidate = entries.find((entry) => entry.isFile() && entry.name === fallbackName) ??
-            entries.find((entry) => entry.isFile());
-        return candidate ? join(directory, candidate.name) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function firstNonempty(values) {
-    return values.find((value) => value !== undefined && value.length > 0);
-}
-export async function inspectDarwinApp(appPath) {
-    const framework = join(appPath, "Contents", "Frameworks", "Electron Framework.framework");
-    const hasFramework = await isDirectory(framework);
-    const hasPayload = await hasElectronAppPayload(join(appPath, "Contents", "Resources"));
-    if (!hasFramework || !hasPayload) {
-        return undefined;
-    }
-    const info = await readMacInfoPlist(appPath);
-    const directoryName = basename(appPath, ".app");
-    const executablePath = await resolveMacExecutablePath(appPath, info.CFBundleExecutable, directoryName);
-    if (executablePath === undefined) {
-        return undefined;
-    }
-    return {
-        appPath,
-        bundleId: firstNonempty([info.CFBundleIdentifier]),
-        executablePath,
-        name: firstNonempty([info.CFBundleDisplayName, info.CFBundleName]) ?? directoryName,
-        platform: "darwin",
-    };
-}
-async function inspectDirectory(directory) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return { apps: [], skippedCount: 0 };
-    }
-    const apps = [];
-    let skippedCount = 0;
-    for (const entry of entries) {
-        if (!entry.name.endsWith(".app")) {
-            continue;
-        }
-        try {
-            // Inspect in filesystem order and count failures without overlapping app reads.
-            // oxlint-disable-next-line no-await-in-loop
-            const app = await inspectDarwinApp(join(directory, entry.name));
-            if (app) {
-                apps.push(app);
-            }
-        }
-        catch {
-            skippedCount += 1;
-        }
-    }
-    return { apps, skippedCount };
-}
-export async function discoverDarwinApps(directories) {
-    const apps = [];
-    let skippedCount = 0;
-    for (const directory of directories) {
-        // Location priority is observable when duplicate bundles are discovered.
-        // oxlint-disable-next-line no-await-in-loop
-        const scan = await inspectDirectory(directory);
-        apps.push(...scan.apps);
-        skippedCount += scan.skippedCount;
-    }
-    return { apps, skippedCount };
-}

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

@@ -1,136 +0,0 @@
-import { basename } from "node:path";
-function unescapeDesktopValue(value) {
-    return value
-        .replace(/\\s/g, " ")
-        .replace(/\\n/g, "\n")
-        .replace(/\\r/g, "\r")
-        .replace(/\\t/g, "\t")
-        .replace(/\\\\/g, "\\");
-}
-function parseDesktopFields(text) {
-    const fields = new Map();
-    let inDesktopEntry = false;
-    for (const rawLine of text.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (line.length === 0 || line.startsWith("#")) {
-            continue;
-        }
-        if (line.startsWith("[") && line.endsWith("]")) {
-            inDesktopEntry = line === "[Desktop Entry]";
-            continue;
-        }
-        const separator = line.indexOf("=");
-        if (inDesktopEntry && separator > 0) {
-            fields.set(line.slice(0, separator), unescapeDesktopValue(line.slice(separator + 1)));
-        }
-    }
-    return fields;
-}
-function nonempty(value) {
-    return value !== undefined && value.length > 0 ? value : undefined;
-}
-export function parseDesktopFile(text, filePath) {
-    const fields = parseDesktopFields(text);
-    if (fields.get("Type") !== "Application") {
-        return undefined;
-    }
-    if (["NoDisplay", "Hidden"].some((key) => fields.get(key)?.trim().toLowerCase() === "true")) {
-        return undefined;
-    }
-    const exec = nonempty(fields.get("Exec")?.trim());
-    if (exec === undefined) {
-        return undefined;
-    }
-    const desktopId = basename(filePath, ".desktop");
-    return {
-        comment: nonempty(fields.get("Comment")),
-        desktopId,
-        exec,
-        filePath,
-        icon: nonempty(fields.get("Icon")),
-        name: nonempty(fields.get("Name")) ?? desktopId,
-    };
-}
-function stripDesktopExecFieldCodes(exec) {
-    const placeholder = "\u0000PERCENT\u0000";
-    return exec
-        .replaceAll("%%", placeholder)
-        .replace(/%[A-Za-z]/g, "")
-        .replaceAll(placeholder, "%");
-}
-class DesktopExecWords {
-    tokens = [];
-    current = "";
-    quote;
-    escaped = false;
-    parse(exec) {
-        for (const char of stripDesktopExecFieldCodes(exec)) {
-            this.accept(char);
-        }
-        if (this.escaped) {
-            this.current += "\\";
-        }
-        this.flush();
-        return this.tokens;
-    }
-    flush() {
-        if (this.current.length > 0) {
-            this.tokens.push(this.current);
-            this.current = "";
-        }
-    }
-    accept(char) {
-        if (this.escaped) {
-            this.current += char;
-            this.escaped = false;
-            return;
-        }
-        if (char === "\\") {
-            this.escaped = true;
-            return;
-        }
-        if (this.quote !== undefined) {
-            if (char === this.quote) {
-                this.quote = undefined;
-            }
-            else {
-                this.current += char;
-            }
-            return;
-        }
-        if (char === '"' || char === "'") {
-            this.quote = char;
-            return;
-        }
-        if (/\s/.test(char)) {
-            this.flush();
-            return;
-        }
-        this.current += char;
-    }
-}
-export function tokenizeDesktopExec(exec) {
-    return new DesktopExecWords().parse(exec);
-}
-function envOptionWidth(token) {
-    return ["-u", "--unset", "--chdir"].includes(token) ? 2 : 1;
-}
-export function stripEnvLauncher(tokens) {
-    if (tokens.length === 0 || basename(tokens[0] ?? "") !== "env") {
-        return tokens;
-    }
-    let index = 1;
-    while (index < tokens.length) {
-        const token = tokens[index] ?? "";
-        if (token.startsWith("-")) {
-            index += envOptionWidth(token);
-            continue;
-        }
-        if (/^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token)) {
-            index += 1;
-            continue;
-        }
-        break;
-    }
-    return tokens.slice(index);
-}

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

@@ -1,90 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import { access, readdir, realpath, stat } from "node:fs/promises";
-import { basename, dirname, extname, join } from "node:path";
-import { pathExists } from "../fs-utils.js";
-export async function isDirectory(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function isFile(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function isExecutableFile(path) {
-    try {
-        if (!(await stat(path)).isFile()) {
-            return false;
-        }
-        await access(path, fsConstants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function resolveRealPath(path) {
-    try {
-        return await realpath(path);
-    }
-    catch {
-        return path;
-    }
-}
-export async function directoryContainsChromePak(directory) {
-    try {
-        const entries = await readdir(directory, { withFileTypes: true });
-        return entries.some((entry) => entry.isFile() && /^chrome_.*\.pak$/i.test(entry.name));
-    }
-    catch {
-        return false;
-    }
-}
-export async function hasElectronAppPayload(resourcesDirectory) {
-    return ((await pathExists(join(resourcesDirectory, "app.asar"))) ||
-        (await pathExists(join(resourcesDirectory, "default_app.asar"))) ||
-        (await isDirectory(join(resourcesDirectory, "app"))));
-}
-export async function hasLinuxElectronEvidence(executablePath) {
-    const resolved = await resolveRealPath(executablePath);
-    if (!(await isExecutableFile(resolved))) {
-        return false;
-    }
-    const directory = dirname(resolved);
-    if (!(await directoryContainsChromePak(directory))) {
-        return false;
-    }
-    for (const base of [directory, dirname(directory)]) {
-        // Ordered evidence checks avoid unnecessary filesystem work after the first match.
-        // oxlint-disable-next-line no-await-in-loop
-        if (await hasElectronAppPayload(join(base, "resources"))) {
-            return true;
-        }
-    }
-    return false;
-}
-export async function inspectWin32Executable(executablePath) {
-    const resolved = await resolveRealPath(executablePath);
-    if (!(await isExecutableFile(resolved))) {
-        return undefined;
-    }
-    const directory = dirname(resolved);
-    const hasAppPayload = await hasElectronAppPayload(join(directory, "resources"));
-    const hasPak = (await directoryContainsChromePak(directory)) ||
-        (await pathExists(join(directory, "resources.pak")));
-    if (!hasAppPayload || !hasPak) {
-        return undefined;
-    }
-    return {
-        executablePath: resolved,
-        name: basename(resolved, extname(resolved)),
-        platform: "win32",
-    };
-}

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

@@ -1,93 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import { basename, extname, isAbsolute, join } from "node:path";
-import { parseDesktopFile, stripEnvLauncher, tokenizeDesktopExec } from "./discovery-desktop.js";
-import { hasLinuxElectronEvidence, resolveRealPath } from "./discovery-evidence.js";
-import { findExecutableInPath, pathIsWithin, resolveFlatpakExecutable, resolveSnapExecutable, } from "./discovery-packages.js";
-async function resolveLinuxExecutable(entry, locations) {
-    const tokens = stripEnvLauncher(tokenizeDesktopExec(entry.exec));
-    const token = tokens.at(0);
-    if (token === undefined || token.length === 0) {
-        return undefined;
-    }
-    if (basename(token) === "flatpak") {
-        const path = await resolveFlatpakExecutable(tokens, entry, locations);
-        return path === undefined ? undefined : { executablePath: path, packageSource: "flatpak" };
-    }
-    const executablePath = isAbsolute(token)
-        ? token
-        : await findExecutableInPath(token, locations.pathEnv);
-    if (executablePath === undefined) {
-        return undefined;
-    }
-    if (pathIsWithin(executablePath, locations.snapBinDirectory)) {
-        const path = await resolveSnapExecutable(executablePath, entry, locations);
-        return path === undefined ? undefined : { executablePath: path, packageSource: "snap" };
-    }
-    return { executablePath: await resolveRealPath(executablePath), packageSource: "desktop" };
-}
-async function inspectLinuxDesktopFile(filePath, locations) {
-    let text;
-    try {
-        text = await readFile(filePath, "utf8");
-    }
-    catch {
-        return undefined;
-    }
-    const entry = parseDesktopFile(text, filePath);
-    if (!entry) {
-        return undefined;
-    }
-    const resolution = await resolveLinuxExecutable(entry, locations);
-    if (!resolution || !(await hasLinuxElectronEvidence(resolution.executablePath))) {
-        return undefined;
-    }
-    return {
-        comment: entry.comment,
-        desktopId: entry.desktopId,
-        executablePath: resolution.executablePath,
-        icon: entry.icon,
-        name: entry.name,
-        packageSource: resolution.packageSource,
-        platform: "linux",
-    };
-}
-async function inspectDirectory(directory, locations) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return { apps: [], skippedCount: 0 };
-    }
-    const apps = [];
-    let skippedCount = 0;
-    for (const entry of entries) {
-        if (!entry.isFile() || extname(entry.name) !== ".desktop") {
-            continue;
-        }
-        try {
-            // Preserve desktop-file priority and bound concurrent package scans to one.
-            // oxlint-disable-next-line no-await-in-loop
-            const app = await inspectLinuxDesktopFile(join(directory, entry.name), locations);
-            if (app) {
-                apps.push(app);
-            }
-        }
-        catch {
-            skippedCount += 1;
-        }
-    }
-    return { apps, skippedCount };
-}
-export async function discoverLinuxApps(locations) {
-    const apps = [];
-    let skippedCount = 0;
-    for (const directory of locations.linuxDesktopDirectories) {
-        // Location order determines which duplicate desktop entry is retained.
-        // oxlint-disable-next-line no-await-in-loop
-        const scan = await inspectDirectory(directory, locations);
-        apps.push(...scan.apps);
-        skippedCount += scan.skippedCount;
-    }
-    return { apps, skippedCount };
-}

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

@@ -1,162 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
-import { hasLinuxElectronEvidence, isDirectory, isFile, resolveRealPath, } from "./discovery-evidence.js";
-const MAX_DEPTH = 7;
-const MAX_ENTRIES = 5_000;
-const NON_EXECUTABLE_EXTENSIONS = new Set([
-    ".asar",
-    ".dat",
-    ".desktop",
-    ".json",
-    ".md",
-    ".pak",
-    ".png",
-    ".so",
-    ".txt",
-]);
-export function pathIsWithin(path, parent) {
-    const relativePath = relative(resolve(parent), resolve(path));
-    return relativePath.length === 0 || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-export async function findExecutableInPath(command, pathEnv) {
-    if (command.includes("/")) {
-        return undefined;
-    }
-    for (const directory of pathEnv.split(":")) {
-        if (directory.length === 0) {
-            continue;
-        }
-        const candidate = join(directory, command);
-        // PATH priority requires returning the first present file, not the fastest stat.
-        // oxlint-disable-next-line no-await-in-loop
-        if (await isFile(candidate)) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-class ElectronBinarySearch {
-    preferredNames;
-    candidates = [];
-    visitedEntries = 0;
-    constructor(preferredNames) {
-        this.preferredNames = new Set(preferredNames.filter((name) => name.length > 0));
-    }
-    async find(root) {
-        if (!(await isDirectory(root))) {
-            return undefined;
-        }
-        const preferred = await this.visit(root, 0);
-        if (preferred !== undefined) {
-            return preferred;
-        }
-        for (const candidate of this.candidates) {
-            // Keep DFS candidate order and stop at the first verified fallback executable.
-            // oxlint-disable-next-line no-await-in-loop
-            if (await hasLinuxElectronEvidence(candidate)) {
-                return resolveRealPath(candidate);
-            }
-        }
-        return undefined;
-    }
-    async visit(directory, depth) {
-        if (depth > MAX_DEPTH || this.visitedEntries >= MAX_ENTRIES) {
-            return undefined;
-        }
-        let entries;
-        try {
-            entries = await readdir(directory, { withFileTypes: true });
-        }
-        catch {
-            return undefined;
-        }
-        for (const entry of entries) {
-            this.visitedEntries += 1;
-            if (this.visitedEntries > MAX_ENTRIES) {
-                return undefined;
-            }
-            // The shared entry budget and preferred-match DFS ordering require serialized traversal.
-            // oxlint-disable-next-line no-await-in-loop
-            const found = await this.inspectEntry(directory, entry, depth);
-            if (found !== undefined) {
-                return found;
-            }
-        }
-        return undefined;
-    }
-    async inspectEntry(directory, entry, depth) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            return this.visit(path, depth + 1);
-        }
-        if (!entry.isFile() || NON_EXECUTABLE_EXTENSIONS.has(extname(path).toLowerCase())) {
-            return undefined;
-        }
-        if (this.preferredNames.has(entry.name) && (await hasLinuxElectronEvidence(path))) {
-            return resolveRealPath(path);
-        }
-        this.candidates.push(path);
-        return undefined;
-    }
-}
-export async function resolveSnapExecutable(commandPath, entry, locations) {
-    const commandName = basename(commandPath);
-    const names = [commandName, commandName.split(".")[0] ?? "", entry.desktopId.split(".")[0] ?? ""];
-    for (const snapName of new Set(names.filter((name) => name.length > 0))) {
-        const root = join(locations.snapMountDirectory, snapName, "current");
-        // Native package name priority determines which executable wins.
-        // oxlint-disable-next-line no-await-in-loop
-        const candidate = await new ElectronBinarySearch([
-            commandName,
-            commandName.split(".").at(-1) ?? commandName,
-        ]).find(root);
-        if (candidate !== undefined) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function getFlatpakAppId(tokens, desktopId) {
-    for (let index = tokens.length - 1; index >= 0; index -= 1) {
-        const token = tokens[index] ?? "";
-        if (!token.startsWith("-") && token.includes(".") && token !== "flatpak") {
-            return token;
-        }
-    }
-    return desktopId;
-}
-function getFlatpakCommandName(tokens) {
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index] ?? "";
-        if (token.startsWith("--command=")) {
-            return token.slice("--command=".length);
-        }
-        if (token === "--command") {
-            return tokens[index + 1];
-        }
-    }
-    return undefined;
-}
-function getFlatpakRoots(entry, locations) {
-    const userExport = join(locations.homeDir, ".local", "share", "flatpak", "exports", "share", "applications");
-    if (pathIsWithin(entry.filePath, userExport)) {
-        return [locations.flatpakUserAppDirectory, locations.flatpakSystemAppDirectory];
-    }
-    if (pathIsWithin(entry.filePath, "/var/lib/flatpak/exports/share/applications")) {
-        return [locations.flatpakSystemAppDirectory, locations.flatpakUserAppDirectory];
-    }
-    return [locations.flatpakUserAppDirectory, locations.flatpakSystemAppDirectory];
-}
-export async function resolveFlatpakExecutable(tokens, entry, locations) {
-    const appId = getFlatpakAppId(tokens, entry.desktopId);
-    const commandName = getFlatpakCommandName(tokens);
-    for (const root of getFlatpakRoots(entry, locations)) {
-        // Preserve user/system installation priority; each root has its own bounded scan.
-        // oxlint-disable-next-line no-await-in-loop
-        const candidate = await new ElectronBinarySearch(commandName === undefined ? [] : [commandName]).find(join(root, appId, "current", "active", "files"));
-        if (candidate !== undefined) {
-            return candidate;
-        }
-    }
-    return undefined;
-}

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

@@ -1,2 +0,0 @@
-export const ELECTRON_DISCOVERY_DEFAULT_MAX_RESULTS = 50;
-export const ELECTRON_DISCOVERY_MAX_RESULTS = 200;