pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/config-validation.js

@@ -1,231 +0,0 @@
-// @ts-check
-import { EXA_SEARCH_TYPES, WEB_SEARCH_PROVIDERS, getWebSearchProviderDescriptor, isWebSearchProvider, } from "./config-providers.js";
-/** @typedef {import("./config-providers.js").WebSearchProvider} WebSearchProvider */
-/** @typedef {import("./config-providers.js").ExaSearchType} ExaSearchType */
-/** @typedef {"explicit-only" | "authenticated-only" | "always"} BrowserDefaultProfilePolicy */
-/** @typedef {"global" | "project" | "override"} ConfigLayerScope */
-/** @typedef {{ readonly name: string; readonly policy?: BrowserDefaultProfilePolicy }} BrowserDefaultProfileConfig */
-/** @typedef {{ readonly enabled?: boolean; readonly preferredProvider?: WebSearchProvider; readonly defaultSearchType?: ExaSearchType; readonly braveApiKey?: string; readonly exaApiKey?: string }} WebSearchConfig */
-/** @typedef {{ readonly defaultProfile?: BrowserDefaultProfileConfig; readonly executablePath?: string }} BrowserConfig */
-/** @typedef {{ readonly version?: 1; readonly webSearch?: WebSearchConfig; readonly browser?: BrowserConfig }} AgentBrowserConfig */
-/** @typedef {{ readonly config: AgentBrowserConfig; readonly path: string; readonly scope: ConfigLayerScope }} ConfigLayer */
-/** Validation deliberately appends diagnostics to the caller's collectors.
- * @typedef {string[]} ConfigDiagnostics */
-/** @param {unknown} value
- * @returns {value is Readonly<Record<string, unknown>>} */
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors */
-function validateString(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    if (typeof value !== "string") {
-        errors.push(`${path} must be a string.`);
-        return;
-    }
-    return value;
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors */
-function validateBoolean(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    if (typeof value !== "boolean") {
-        errors.push(`${path} must be a boolean.`);
-        return;
-    }
-    return value;
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @returns {WebSearchProvider | undefined} */
-export function validateWebSearchProvider(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    const provider = validateString(value, path, errors)?.trim();
-    if (provider === undefined) {
-        return;
-    }
-    if (!isWebSearchProvider(provider)) {
-        errors.push(`${path} must be one of ${WEB_SEARCH_PROVIDERS.join(", ")}.`);
-        return;
-    }
-    return provider;
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @returns {ExaSearchType | undefined} */
-function validateExaSearchType(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    const searchType = validateString(value, path, errors)?.trim();
-    if (searchType === undefined) {
-        return;
-    }
-    const supported = EXA_SEARCH_TYPES.find((candidate) => candidate === searchType);
-    if (supported === undefined) {
-        errors.push(`${path} must be one of ${EXA_SEARCH_TYPES.join(", ")}.`);
-    }
-    return supported;
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @returns {BrowserDefaultProfileConfig | undefined} */
-function validateBrowserDefaultProfile(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    if (!isRecord(value)) {
-        errors.push(`${path} must be an object.`);
-        return;
-    }
-    const name = validateString(value.name, `${path}.name`, errors)?.trim();
-    if (name === undefined || name.length === 0) {
-        errors.push(`${path}.name must not be blank.`);
-        return;
-    }
-    const policy = validateString(value.policy, `${path}.policy`, errors) ?? "authenticated-only";
-    if (policy !== "explicit-only" && policy !== "authenticated-only" && policy !== "always") {
-        errors.push(`${path}.policy must be one of explicit-only, authenticated-only, always.`);
-        return;
-    }
-    return { name, policy };
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @returns {WebSearchConfig | undefined} */
-function validateWebSearchConfig(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    if (!isRecord(value)) {
-        errors.push(`${path} must be an object.`);
-        return;
-    }
-    const enabled = validateBoolean(value.enabled, `${path}.enabled`, errors);
-    const preferredProvider = validateWebSearchProvider(value.preferredProvider, `${path}.preferredProvider`, errors);
-    const defaultSearchType = validateExaSearchType(value.defaultSearchType, `${path}.defaultSearchType`, errors);
-    /** @type {Partial<Record<import("./config-providers.js").WebSearchProviderConfigKey, string>>} */
-    const keys = {};
-    for (const provider of WEB_SEARCH_PROVIDERS) {
-        const { configKey } = getWebSearchProviderDescriptor(provider);
-        const apiKey = validateString(value[configKey], `${path}.${configKey}`, errors);
-        if (apiKey !== undefined) {
-            keys[configKey] = apiKey;
-        }
-    }
-    const config = {
-        ...(enabled !== undefined ? { enabled } : {}),
-        ...(preferredProvider !== undefined ? { preferredProvider } : {}),
-        ...(defaultSearchType !== undefined ? { defaultSearchType } : {}),
-        ...keys,
-    };
-    return Object.keys(config).length > 0 ? config : undefined;
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @returns {BrowserConfig | undefined} */
-function validateBrowserConfig(value, path, errors) {
-    if (value === undefined) {
-        return;
-    }
-    if (!isRecord(value)) {
-        errors.push(`${path} must be an object.`);
-        return;
-    }
-    const defaultProfile = validateBrowserDefaultProfile(value.defaultProfile, `${path}.defaultProfile`, errors);
-    const executablePath = validateString(value.executablePath, `${path}.executablePath`, errors)?.trim();
-    return {
-        ...(defaultProfile !== undefined ? { defaultProfile } : {}),
-        ...(executablePath !== undefined && executablePath.length > 0 ? { executablePath } : {}),
-    };
-}
-/** @param {unknown} value
- * @param {string} path
- * @param {ConfigDiagnostics} errors
- * @param {ConfigDiagnostics} warnings
- * @returns {AgentBrowserConfig | undefined} */
-export function validateAgentBrowserConfig(value, path, errors, warnings) {
-    if (!isRecord(value)) {
-        errors.push(`${path} must contain a JSON object.`);
-        return;
-    }
-    if (value.version !== undefined && value.version !== 1) {
-        errors.push(`${path}.version must be 1 when present.`);
-    }
-    const webSearch = validateWebSearchConfig(value.webSearch, `${path}.webSearch`, errors);
-    const browser = validateBrowserConfig(value.browser, `${path}.browser`, errors);
-    for (const key of Object.keys(value)) {
-        if (!["version", "webSearch", "browser"].includes(key)) {
-            warnings.push(`${path}.${key} is not a recognized pi-agent-browser-native config field and was ignored.`);
-        }
-    }
-    return {
-        ...(value.version === 1 ? { version: 1 } : {}),
-        ...(webSearch !== undefined ? { webSearch } : {}),
-        ...(browser !== undefined ? { browser } : {}),
-    };
-}
-/** Parse config without retaining native token previews or source-bearing error causes.
- * @param {string} raw
- * @returns {{ readonly ok: true; readonly value: unknown } | { readonly ok: false; readonly error: string }} */
-export function parseAgentBrowserConfigJson(raw) {
-    try {
-        return { ok: true, value: JSON.parse(raw) };
-    }
-    catch (error) {
-        const location = error instanceof Error
-            ? error.message.match(/at position \d+(?: \(line \d+ column \d+\))?/)?.[0]
-            : undefined;
-        return {
-            ok: false,
-            error: location === undefined ? "Invalid JSON." : `Invalid JSON ${location}.`,
-        };
-    }
-}
-/** @param {string} raw
- * @param {string} path
- * @param {ConfigLayerScope} scope
- * @param {ConfigDiagnostics} errors
- * @param {ConfigDiagnostics} warnings
- * @returns {ConfigLayer | undefined} */
-export function parseAgentBrowserConfigLayer(raw, path, scope, errors, warnings) {
-    const parsed = parseAgentBrowserConfigJson(raw);
-    if (!parsed.ok) {
-        errors.push(`Could not parse ${scope} config ${path}: ${parsed.error}`);
-        return;
-    }
-    const config = validateAgentBrowserConfig(parsed.value, path, errors, warnings);
-    return config ? { config, path, scope } : undefined;
-}
-/** @param {unknown} value */
-export function describeUnknownError(value) {
-    switch (typeof value) {
-        case "string":
-            return value;
-        case "number":
-        case "bigint":
-        case "boolean":
-        case "symbol":
-            return String(value);
-        case "undefined":
-            return "undefined";
-        case "object":
-            return value === null ? "null" : Object.prototype.toString.call(value);
-        case "function":
-            return value.toString();
-    }
-}

package/dist/extensions/agent-browser/lib/config.js

@@ -1,69 +0,0 @@
-import { exec as execCallback } from "node:child_process";
-import { promisify } from "node:util";
-import { SECRET_COMMAND_TIMEOUT_MS, getWebSearchCredentialSource, getWebSearchProviderOrder, loadAgentBrowserConfigStateSync, resolveEnvInterpolations, } from "./config-policy.js";
-export { AGENT_BROWSER_CONFIG_ENV, BRAVE_API_KEY_ENV, CONFIG_RELATIVE_PATH, DEFAULT_WEB_SEARCH_PROVIDER, EXA_API_KEY_ENV, EXA_SEARCH_TYPES, GLOBAL_CONFIG_RELATIVE_PATH, SECRET_COMMAND_TIMEOUT_MS, WEB_SEARCH_PROVIDER_CONFIG_KEYS, WEB_SEARCH_PROVIDER_ENV_VARS, WEB_SEARCH_PROVIDERS, buildAgentBrowserConfigState, buildWebSearchCredentialSources, canRegisterWebSearchTool, classifyCredentialSource, formatBrowserExecutableStatus, formatBrowserProfileStatus, getAgentBrowserConfigPaths, getCredentialSourceSummary, getGlobalAgentBrowserConfigPath, getProjectAgentBrowserConfigPath, getWebSearchCredentialSource, getWebSearchProviderDescriptor, getWebSearchProviderLabel, getWebSearchProviderOrder, hasPotentialCredentialSource, isWebSearchProvider, loadAgentBrowserConfigStateSync, mergeAgentBrowserConfig, parseAgentBrowserConfigJson, parseAgentBrowserConfigLayer, resolveEnvInterpolations, summarizeConfigFiles, validateAgentBrowserConfig, validateWebSearchProvider, } from "./config-policy.js";
-// Node's callback-oriented exec returns ChildProcess; promisify intentionally ignores that return.
-// oxlint-disable-next-line typescript/strict-void-return
-const exec = promisify(execCallback);
-export function loadAgentBrowserConfigSync(options = {}) {
-    return loadAgentBrowserConfigStateSync(options);
-}
-async function resolveCommandCredential(rawValue, signal) {
-    const command = rawValue.slice(1).trim();
-    if (command.length === 0) {
-        return undefined;
-    }
-    try {
-        const result = await exec(command, {
-            signal,
-            timeout: SECRET_COMMAND_TIMEOUT_MS,
-            maxBuffer: 1024 * 1024,
-        });
-        const value = result.stdout.trim();
-        return value.length > 0 ? value : undefined;
-    }
-    catch (error) {
-        if (signal?.aborted === true) {
-            throw error;
-        }
-        // The native exec error contains the secret command/stdout/stderr; never expose it as a cause.
-        // oxlint-disable-next-line eslint/preserve-caught-error
-        throw new Error("Credential command failed without exposing command output. Check pi-agent-browser-config web-search status and the configured secret manager command.");
-    }
-}
-async function resolveCredentialSource(source, options = {}) {
-    if (!source) {
-        return undefined;
-    }
-    let value;
-    if (source.kind === "command") {
-        value = await resolveCommandCredential(source.rawValue, options.signal);
-    }
-    else if (source.kind === "env") {
-        value = resolveEnvInterpolations(source.rawValue, options.env ?? process.env)?.trim();
-    }
-    else {
-        value = source.rawValue.trim();
-    }
-    return value !== undefined && value.length > 0 ? { source, value } : undefined;
-}
-export async function resolveWebSearchCredential(state, provider, options = {}) {
-    if (!state.webSearchEnabled || state.errors.length > 0) {
-        return undefined;
-    }
-    return resolveCredentialSource(getWebSearchCredentialSource(state, provider), options);
-}
-export async function resolvePreferredWebSearchCredential(state, options = {}) {
-    if (!state.webSearchEnabled || state.errors.length > 0) {
-        return undefined;
-    }
-    for (const provider of getWebSearchProviderOrder(state, options.provider)) {
-        // Resolve in configured preference order; later secret commands must not run once a key resolves.
-        // oxlint-disable-next-line no-await-in-loop
-        const credential = await resolveWebSearchCredential(state, provider, options);
-        if (credential) {
-            return { provider, credential };
-        }
-    }
-    return undefined;
-}

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

@@ -1,62 +0,0 @@
-import { isRecord } from "../parsing.js";
-const ELECTRON_CDP_FETCH_TIMEOUT_MS = 1_000;
-function asString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-export function parseCdpVersion(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const browser = asString(value.Browser) ?? asString(value.browser);
-    if (browser === undefined) {
-        return undefined;
-    }
-    return {
-        browser,
-        protocolVersion: asString(value["Protocol-Version"]) ?? asString(value.protocolVersion),
-        userAgent: asString(value["User-Agent"]) ?? asString(value.userAgent),
-        v8Version: asString(value["V8-Version"]) ?? asString(value.v8Version),
-        webKitVersion: asString(value["WebKit-Version"]) ?? asString(value.webKitVersion),
-        webSocketDebuggerUrl: asString(value.webSocketDebuggerUrl),
-    };
-}
-export function parseCdpTargets(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isRecord).map((target) => ({
-        id: asString(target.id),
-        title: asString(target.title),
-        type: asString(target.type),
-        url: asString(target.url),
-        webSocketDebuggerUrl: asString(target.webSocketDebuggerUrl),
-    }));
-}
-export async function fetchCdpJson(url, signal) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), ELECTRON_CDP_FETCH_TIMEOUT_MS);
-    try {
-        const response = await fetch(url, {
-            signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal,
-        });
-        if (!response.ok) {
-            return undefined;
-        }
-        return (await response.json());
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-export function boundElectronProbeString(value, maxLength = 240) {
-    const trimmed = value?.trim();
-    if (trimmed === undefined || trimmed.length === 0) {
-        return undefined;
-    }
-    return trimmed.length > maxLength
-        ? `${trimmed.slice(0, Math.max(0, maxLength - 3))}...`
-        : trimmed;
-}

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

@@ -1,274 +0,0 @@
-import { lstat, rm } from "node:fs/promises";
-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;
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-function isPidAlive(pid) {
-    if (pid === undefined || !Number.isSafeInteger(pid) || pid <= 0) {
-        return undefined;
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        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) {
-        return { targets: [] };
-    }
-    const targets = parseCdpTargets(await fetchCdpJson(`http://127.0.0.1:${port}/json/list`, signal));
-    return { targets, version };
-}
-export async function inspectElectronLaunchStatus(record, signal) {
-    const cdp = await isPortAlive(record.port, signal);
-    let userDataDirState;
-    try {
-        await lstat(record.userDataDir);
-        userDataDirState = "present";
-    }
-    catch (error) {
-        userDataDirState = isRecord(error) && error.code === "ENOENT" ? "absent" : "unknown";
-    }
-    return {
-        cleanupState: record.cleanupState,
-        launchId: record.launchId,
-        pid: record.pid,
-        pidAlive: isPidAlive(record.pid),
-        port: record.port,
-        portAlive: cdp.version !== undefined,
-        targets: cdp.targets,
-        userDataDirState,
-        version: cdp.version,
-    };
-}
-function hasProcessExited(child, pid) {
-    // A Windows PID probe can report ESRCH during termination, before the
-    // tracked process has exited and released its executable/resources.
-    return child ? child.exitCode !== null || child.signalCode !== null : isPidAlive(pid) === false;
-}
-async function waitForProcessExit(child, pid, deadlineMs) {
-    while (Date.now() <= deadlineMs) {
-        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 getRestoredProcessVerificationError(record) {
-    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.`;
-    }
-    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 === undefined || !Number.isSafeInteger(pid) || pid <= 0) {
-        return false;
-    }
-    try {
-        process.kill(pid, signal);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function killProcessGroup(processGroupId, signal) {
-    if (process.platform === "win32" ||
-        processGroupId === undefined ||
-        !Number.isSafeInteger(processGroupId) ||
-        processGroupId <= 0) {
-        return false;
-    }
-    try {
-        process.kill(-processGroupId, signal);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function signalRestoredLaunchProcess(record, signal) {
-    return killProcessGroup(record.processGroupId, signal) || killPid(record.pid, signal);
-}
-async function cleanupProcess(record, child, deadlineMs) {
-    if (record.pid === undefined || record.pid === 0 || Number.isNaN(record.pid)) {
-        return { resource: "process", state: "skipped" };
-    }
-    if (hasProcessExited(child, record.pid)) {
-        return { resource: "process", state: "already-gone" };
-    }
-    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 {
-        killPid(record.pid, "SIGTERM");
-    }
-    if (await waitForProcessExit(child, record.pid, deadlineMs)) {
-        return { resource: "process", state: "removed" };
-    }
-    if (child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
-    }
-    else {
-        killPid(record.pid, "SIGKILL");
-    }
-    if (await waitForProcessExit(child, 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 cleanupUserDataDir(record) {
-    if (record.userDataDir.length === 0) {
-        return { resource: "user-data-dir", state: "skipped" };
-    }
-    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 !== 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",
-        };
-    }
-    catch (error) {
-        return {
-            error: error instanceof Error ? error.message : stringifyUnknown(error),
-            resource: "user-data-dir",
-            state: "failed",
-        };
-    }
-}
-function shouldSkipUserDataDirCleanup(processStep, debugPortStep) {
-    if (processStep.state === "failed") {
-        return `Skipped because process cleanup failed: ${processStep.error ?? "process state could not be verified"}.`;
-    }
-    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" };
-}
-function summarizeCleanup(launchId, steps) {
-    const remainingResources = steps
-        .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 {
-        partial,
-        remainingResources,
-        summary: partial
-            ? `Electron cleanup for ${launchId} is partial; remaining resources: ${remainingResources.join(", ")}.`
-            : `Electron cleanup for ${launchId} completed.`,
-    };
-}
-export async function cleanupElectronLaunchResources(options) {
-    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 !== 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);
-    return {
-        launchId: options.record.launchId,
-        partial: summary.partial,
-        record: {
-            ...options.record,
-            cleanupState: summary.partial ? "partial" : "cleaned",
-        },
-        remainingResources: summary.remainingResources,
-        steps,
-        summary: summary.summary,
-    };
-}