pi-agent-browser-native 0.9.3 → 0.9.5

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

@@ -1,34 +1,35 @@
-import { execFile } from "node:child_process";
 import { lstat, rm } from "node:fs/promises";
-import { win32 } from "node:path";
-import { promisify } from "node:util";
-import { fetchCdpJson, parseCdpTargets, parseCdpVersion } from "./cdp.js";
-import { ELECTRON_PROFILE_DIR_PREFIX } from "./launch.js";
+import { fetchCdpJson, parseCdpTargets, parseCdpVersion, } from "./cdp.js";
+import { ELECTRON_PROFILE_DIR_PREFIX } from "./launch-types.js";
 import { pathExists } from "../fs-utils.js";
+import { isRecord } from "../parsing.js";
+import { readProcessStartIdentity, processStartIdentitiesMatch } from "../process-identity.js";
+import { stringifyUnknown } from "../results/text.js";
 import { getSecureTempChildDirectoryValidationError } from "../temp.js";
 const ELECTRON_CLEANUP_DEFAULT_TIMEOUT_MS = 5_000;
 const ELECTRON_CLEANUP_POLL_INTERVAL_MS = 100;
-const RESTORED_PROCESS_COMMAND_TIMEOUT_MS = 1_000;
-const execFileAsync = promisify(execFile);
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
 }
 function isPidAlive(pid) {
-    if (!pid || !Number.isSafeInteger(pid) || pid <= 0)
+    if (pid === undefined || !Number.isSafeInteger(pid) || pid <= 0) {
         return undefined;
+    }
     try {
         process.kill(pid, 0);
         return true;
     }
     catch (error) {
-        const code = error.code;
-        return code === "EPERM" ? true : false;
+        return isRecord(error) && error.code === "EPERM";
     }
 }
 async function isPortAlive(port, signal) {
     const version = parseCdpVersion(await fetchCdpJson(`http://127.0.0.1:${port}/json/version`, signal));
-    if (!version)
+    if (!version) {
         return { targets: [] };
+    }
     const targets = parseCdpTargets(await fetchCdpJson(`http://127.0.0.1:${port}/json/list`, signal));
     return { targets, version };
 }
@@ -40,7 +41,7 @@ export async function inspectElectronLaunchStatus(record, signal) {
         userDataDirState = "present";
     }
     catch (error) {
-        userDataDirState = error.code === "ENOENT" ? "absent" : "unknown";
+        userDataDirState = isRecord(error) && error.code === "ENOENT" ? "absent" : "unknown";
     }
     return {
         cleanupState: record.cleanupState,
@@ -61,52 +62,32 @@ function hasProcessExited(child, pid) {
 }
 async function waitForProcessExit(child, pid, deadlineMs) {
     while (Date.now() <= deadlineMs) {
-        if (hasProcessExited(child, pid))
+        if (hasProcessExited(child, pid)) {
             return true;
+        }
+        // Polling observes exit between sleeps; parallel waits cannot preserve the deadline.
+        // oxlint-disable-next-line no-await-in-loop
         await sleep(ELECTRON_CLEANUP_POLL_INTERVAL_MS);
     }
     return hasProcessExited(child, pid);
 }
-async function readPidCommandLine(pid) {
-    if (!pid || !Number.isSafeInteger(pid) || pid <= 0)
-        return undefined;
-    try {
-        // Win32_Process.CommandLine is the native ownership evidence; process
-        // start time (used by daemon-policy locks) cannot prove profile ownership.
-        const systemRoot = process.env.SystemRoot;
-        const windowsRoot = systemRoot && win32.isAbsolute(systemRoot) ? systemRoot : "C:\\Windows";
-        const file = process.platform === "win32"
-            ? win32.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
-            : "ps";
-        const args = process.platform === "win32"
-            ? ["-NoProfile", "-NonInteractive", "-Command",
-                `[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); $p = [wmi]"Win32_Process.Handle='${pid}'"; [Console]::WriteLine($p.CommandLine)`]
-            : ["-ww", "-p", String(pid), "-o", "command="];
-        const { stdout } = await execFileAsync(file, args, {
-            timeout: RESTORED_PROCESS_COMMAND_TIMEOUT_MS,
-        });
-        return stdout.trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function restoredLaunchCommandMatchesRecord(record, commandLine) {
-    return commandLine?.includes(`--user-data-dir=${record.userDataDir}`) === true;
-}
 async function getRestoredProcessVerificationError(record) {
-    const commandLine = await readPidCommandLine(record.pid);
-    if (!commandLine) {
-        return `PID ${record.pid} is alive, but this session has no tracked child handle and its command line could not be inspected; refusing to signal a restored PID that may have been reused.`;
+    if (record.startIdentity === undefined || record.startIdentity.length === 0) {
+        return `PID ${String(record.pid)} is alive, but this session has no tracked child handle or recorded start identity; refusing to signal a restored PID that may have been reused.`;
     }
-    if (!restoredLaunchCommandMatchesRecord(record, commandLine)) {
-        return `PID ${record.pid} is alive, but this session has no tracked child handle and its command line does not include wrapper-owned user data dir ${record.userDataDir}; refusing to signal a restored PID that may have been reused.`;
+    const currentIdentity = record.pid === undefined ? undefined : await readProcessStartIdentity(record.pid);
+    if (currentIdentity === undefined) {
+        return `PID ${String(record.pid)} is alive, but its current start identity could not be inspected; refusing to signal a restored PID that may have been reused.`;
+    }
+    if (!processStartIdentitiesMatch(record.startIdentity, currentIdentity)) {
+        return `PID ${String(record.pid)} is alive, but its start identity does not match the wrapper launch record; refusing to signal a restored PID that may have been reused.`;
     }
     return undefined;
 }
 function killPid(pid, signal) {
-    if (!pid || !Number.isSafeInteger(pid) || pid <= 0)
+    if (pid === undefined || !Number.isSafeInteger(pid) || pid <= 0) {
         return false;
+    }
     try {
         process.kill(pid, signal);
         return true;
@@ -116,8 +97,12 @@ function killPid(pid, signal) {
     }
 }
 function killProcessGroup(processGroupId, signal) {
-    if (process.platform === "win32" || !processGroupId || !Number.isSafeInteger(processGroupId) || processGroupId <= 0)
+    if (process.platform === "win32" ||
+        processGroupId === undefined ||
+        !Number.isSafeInteger(processGroupId) ||
+        processGroupId <= 0) {
         return false;
+    }
     try {
         process.kill(-processGroupId, signal);
         return true;
@@ -130,68 +115,122 @@ function signalRestoredLaunchProcess(record, signal) {
     return killProcessGroup(record.processGroupId, signal) || killPid(record.pid, signal);
 }
 async function cleanupProcess(record, child, deadlineMs) {
-    if (!record.pid)
+    if (record.pid === undefined || record.pid === 0 || Number.isNaN(record.pid)) {
         return { resource: "process", state: "skipped" };
-    if (hasProcessExited(child, record.pid))
+    }
+    if (hasProcessExited(child, record.pid)) {
         return { resource: "process", state: "already-gone" };
-    if (!child) {
-        const verificationError = await getRestoredProcessVerificationError(record);
-        if (verificationError)
-            return { error: verificationError, resource: "process", state: "failed" };
-        if (!signalRestoredLaunchProcess(record, "SIGTERM")) {
-            return { error: `PID ${record.pid} matched wrapper launch metadata but could not be signaled.`, resource: "process", state: "failed" };
-        }
-        if (await waitForProcessExit(undefined, record.pid, deadlineMs))
-            return { resource: "process", state: "removed" };
-        signalRestoredLaunchProcess(record, "SIGKILL");
-        if (await waitForProcessExit(undefined, record.pid, Date.now() + 1_000))
-            return { resource: "process", state: "removed" };
-        return { error: `PID ${record.pid} remained alive after SIGTERM/SIGKILL.`, resource: "process", state: "failed" };
-    }
-    if (child.exitCode === null && child.signalCode === null)
+    }
+    return child === undefined
+        ? cleanupRestoredProcess(record, deadlineMs)
+        : cleanupTrackedProcess(record, child, deadlineMs);
+}
+async function cleanupRestoredProcess(record, deadlineMs) {
+    const verificationError = await getRestoredProcessVerificationError(record);
+    if (verificationError !== undefined) {
+        return { error: verificationError, resource: "process", state: "failed" };
+    }
+    if (!signalRestoredLaunchProcess(record, "SIGTERM")) {
+        return {
+            error: `PID ${String(record.pid)} matched wrapper launch metadata but could not be signaled.`,
+            resource: "process",
+            state: "failed",
+        };
+    }
+    if (await waitForProcessExit(undefined, record.pid, deadlineMs)) {
+        return { resource: "process", state: "removed" };
+    }
+    const killVerificationError = await getRestoredProcessVerificationError(record);
+    if (killVerificationError !== undefined) {
+        return { error: killVerificationError, resource: "process", state: "failed" };
+    }
+    signalRestoredLaunchProcess(record, "SIGKILL");
+    if (await waitForProcessExit(undefined, record.pid, Date.now() + 1_000)) {
+        return { resource: "process", state: "removed" };
+    }
+    return {
+        error: `PID ${String(record.pid)} remained alive after SIGTERM/SIGKILL.`,
+        resource: "process",
+        state: "failed",
+    };
+}
+async function cleanupTrackedProcess(record, child, deadlineMs) {
+    if (child.exitCode === null && child.signalCode === null) {
         child.kill("SIGTERM");
-    else
+    }
+    else {
         killPid(record.pid, "SIGTERM");
-    if (await waitForProcessExit(child, record.pid, deadlineMs))
+    }
+    if (await waitForProcessExit(child, record.pid, deadlineMs)) {
         return { resource: "process", state: "removed" };
-    if (child.exitCode === null && child.signalCode === null)
+    }
+    if (child.exitCode === null && child.signalCode === null) {
         child.kill("SIGKILL");
-    else
+    }
+    else {
         killPid(record.pid, "SIGKILL");
-    if (await waitForProcessExit(child, record.pid, Date.now() + 1_000))
+    }
+    if (await waitForProcessExit(child, record.pid, Date.now() + 1_000)) {
         return { resource: "process", state: "removed" };
-    return { error: `PID ${record.pid} remained alive after SIGTERM/SIGKILL.`, resource: "process", state: "failed" };
+    }
+    return {
+        error: `PID ${String(record.pid)} remained alive after SIGTERM/SIGKILL.`,
+        resource: "process",
+        state: "failed",
+    };
 }
 async function cleanupUserDataDir(record) {
-    if (!record.userDataDir)
+    if (record.userDataDir.length === 0) {
         return { resource: "user-data-dir", state: "skipped" };
-    if (!await pathExists(record.userDataDir))
+    }
+    if (!(await pathExists(record.userDataDir))) {
         return { resource: "user-data-dir", state: "already-gone" };
+    }
     const validationError = await getSecureTempChildDirectoryValidationError(record.userDataDir, ELECTRON_PROFILE_DIR_PREFIX);
-    if (validationError)
+    if (validationError !== undefined) {
         return { error: validationError, resource: "user-data-dir", state: "failed" };
+    }
     try {
         await rm(record.userDataDir, { force: true, recursive: true });
-        return { resource: "user-data-dir", state: await pathExists(record.userDataDir) ? "failed" : "removed" };
+        return {
+            resource: "user-data-dir",
+            state: (await pathExists(record.userDataDir)) ? "failed" : "removed",
+        };
     }
     catch (error) {
-        return { error: error instanceof Error ? error.message : String(error), resource: "user-data-dir", state: "failed" };
+        return {
+            error: error instanceof Error ? error.message : stringifyUnknown(error),
+            resource: "user-data-dir",
+            state: "failed",
+        };
     }
 }
 function shouldSkipUserDataDirCleanup(processStep, debugPortStep) {
-    if (processStep.state === "failed")
+    if (processStep.state === "failed") {
         return `Skipped because process cleanup failed: ${processStep.error ?? "process state could not be verified"}.`;
-    if (debugPortStep.state === "failed")
+    }
+    if (debugPortStep.state === "failed") {
         return `Skipped because debug port cleanup is incomplete: ${debugPortStep.error ?? "debug port still responds"}.`;
+    }
     return undefined;
 }
 async function cleanupDebugPort(record) {
     const cdp = await isPortAlive(record.port);
-    return cdp.version ? { resource: "debug-port", state: "failed", error: `/json/version still responds on port ${record.port}.` } : { resource: "debug-port", state: "already-gone" };
+    return cdp.version
+        ? {
+            resource: "debug-port",
+            state: "failed",
+            error: `/json/version still responds on port ${record.port}.`,
+        }
+        : { resource: "debug-port", state: "already-gone" };
 }
 function summarizeCleanup(launchId, steps) {
     const remainingResources = steps
-        .filter((step) => step.state === "failed" || (step.resource === "user-data-dir" && step.state === "skipped" && step.error))
+        .filter((step) => step.state === "failed" ||
+        (step.resource === "user-data-dir" &&
+            step.state === "skipped" &&
+            step.error !== undefined &&
+            step.error.length > 0))
         .map((step) => step.resource);
     const partial = remainingResources.length > 0;
     return {
@@ -203,15 +242,21 @@ function summarizeCleanup(launchId, steps) {
     };
 }
 export async function cleanupElectronLaunchResources(options) {
-    const timeoutMs = Number.isSafeInteger(options.timeoutMs) && (options.timeoutMs ?? 0) > 0
+    const timeoutMs = typeof options.timeoutMs === "number" &&
+        Number.isSafeInteger(options.timeoutMs) &&
+        options.timeoutMs > 0
         ? options.timeoutMs
         : ELECTRON_CLEANUP_DEFAULT_TIMEOUT_MS;
     const deadlineMs = Date.now() + timeoutMs;
     const processStep = await cleanupProcess(options.record, options.child, deadlineMs);
     const debugPortStep = await cleanupDebugPort(options.record);
     const userDataDirSkipReason = shouldSkipUserDataDirCleanup(processStep, debugPortStep);
-    const userDataDirStep = userDataDirSkipReason
-        ? { error: userDataDirSkipReason, resource: "user-data-dir", state: "skipped" }
+    const userDataDirStep = userDataDirSkipReason !== undefined
+        ? {
+            error: userDataDirSkipReason,
+            resource: "user-data-dir",
+            state: "skipped",
+        }
         : await cleanupUserDataDir(options.record);
     const steps = [processStep, debugPortStep, userDataDirStep];
     const summary = summarizeCleanup(options.record.launchId, steps);

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

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

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

@@ -0,0 +1,90 @@
+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",
+    };
+}