pi-agent-browser-native 0.9.3 → 0.9.5

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

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

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

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