pi-agent-browser-native 0.9.4 → 0.9.6

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

@@ -1,329 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { rm } from "node:fs/promises";
-import { discoverElectronApps, inspectElectronAppPath, inspectElectronExecutablePath, } from "./discovery.js";
-import { createSecureTempDirectory, preserveSecureTempDirectory } from "../temp.js";
-import { stringifyUnknown } from "../results/text.js";
-import { isElectronLaunchAborted, pollCdpMetadata, pollDevToolsActivePort, } from "./launch-monitor.js";
-import { ElectronLaunchProcess } from "./launch-process.js";
-import { ELECTRON_LAUNCH_RECORD_VERSION, ELECTRON_PROFILE_DIR_PREFIX, } from "./launch-types.js";
-export { ELECTRON_LAUNCH_RECORD_VERSION, ELECTRON_PROFILE_DIR_PREFIX } from "./launch-types.js";
-const DEFAULT_TIMEOUT_MS = 15_000;
-const MAX_TIMEOUT_MS = 120_000;
-const DEFAULT_APP_ARGS = ["--disable-extensions", "--no-first-run", "--no-default-browser-check"];
-function normalizeTimeoutMs(timeoutMs) {
-    if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
-        return DEFAULT_TIMEOUT_MS;
-    }
-    return Math.min(timeoutMs, MAX_TIMEOUT_MS);
-}
-function normalizeIdentifier(value) {
-    const trimmed = value?.trim().toLowerCase();
-    return trimmed !== undefined && trimmed.length > 0 ? trimmed : undefined;
-}
-function policyEntryMatchesApp(entry, app) {
-    const normalized = normalizeIdentifier(entry);
-    if (normalized === undefined) {
-        return false;
-    }
-    const identifiers = [
-        app.name,
-        app.bundleId,
-        app.desktopId,
-        app.appPath,
-        app.executablePath,
-    ].filter((value) => typeof value === "string" && value.trim().length > 0);
-    return identifiers.some((identifier) => identifier.toLowerCase().includes(normalized));
-}
-function evaluateLaunchPolicy(options, target) {
-    const denyEntry = options.deny?.find((entry) => policyEntryMatchesApp(entry, target));
-    if (denyEntry !== undefined && denyEntry.length > 0) {
-        return {
-            entry: denyEntry,
-            list: "deny",
-            message: `Electron launch blocked by caller deny policy: ${denyEntry}`,
-        };
-    }
-    if (options.allow !== undefined && options.allow.length > 0) {
-        const allowEntry = options.allow.find((entry) => policyEntryMatchesApp(entry, target));
-        if (allowEntry === undefined || allowEntry.length === 0) {
-            return {
-                list: "allow",
-                message: "Electron launch blocked because the resolved app did not match caller allow policy.",
-            };
-        }
-    }
-    return undefined;
-}
-async function resolveLaunchTarget(options) {
-    if (options.appPath !== undefined && options.appPath.length > 0) {
-        return inspectElectronAppPath(options.appPath);
-    }
-    if (options.executablePath !== undefined && options.executablePath.length > 0) {
-        return inspectElectronExecutablePath(options.executablePath);
-    }
-    const discovery = await discoverElectronApps({
-        maxResults: 200,
-        query: options.bundleId ?? options.appName,
-    });
-    return selectDiscoveredTarget(discovery.apps, options);
-}
-function selectDiscoveredTarget(apps, options) {
-    if ((options.bundleId ?? "").length > 0) {
-        const bundleId = normalizeIdentifier(options.bundleId);
-        return apps.find((app) => normalizeIdentifier(app.bundleId) === bundleId);
-    }
-    if ((options.appName ?? "").length > 0) {
-        const name = normalizeIdentifier(options.appName);
-        return apps.find((app) => normalizeIdentifier(app.name) === name) ?? apps.at(0);
-    }
-    return undefined;
-}
-function targetMatchesType(target, type) {
-    return type === undefined || type === "any" || target.type === type;
-}
-function selectConnectArg(port, metadata, type) {
-    const targetSocket = metadata.targets.find((target) => targetMatchesType(target, type) &&
-        target.webSocketDebuggerUrl !== undefined &&
-        target.webSocketDebuggerUrl.length > 0)?.webSocketDebuggerUrl;
-    return targetSocket ?? metadata.version.webSocketDebuggerUrl ?? String(port);
-}
-function launchFailureMessage(reason, target, detail) {
-    const label = target ? `${target.name} (${target.appPath ?? target.executablePath})` : "target";
-    switch (reason) {
-        case "aborted":
-            return `Electron launch was aborted${target ? ` before ${label} finished starting` : " before the app started"}.`;
-        case "non-electron-target":
-            return `Electron launch rejected: ${label} does not have Electron framework evidence.`;
-        case "policy-blocked":
-            return detail ?? `Electron launch blocked by caller policy for ${label}.`;
-        case "single-instance-conflict":
-            return `Electron launch did not expose a debug port for ${label}; the app may already be running as a single-instance Electron app. Quit the running app and retry.`;
-        case "port-not-found":
-            return `Electron launch found a DevToolsActivePort for ${label}, but /json/version never returned a valid CDP payload.`;
-        case "spawn-error":
-            return `Electron launch failed while starting ${label}${detail !== undefined && detail.length > 0 ? `: ${detail}` : "."}`;
-        case "timeout":
-            return `Electron launch timed out waiting for DevToolsActivePort for ${label}.`;
-    }
-}
-/** Owns one profile and process attempt; only a successful result transfers them to the host. */
-class ElectronLaunchAttempt {
-    options;
-    target;
-    userDataDir;
-    process;
-    startedAtMs;
-    timeoutMs;
-    deadlineMs;
-    appArgs;
-    constructor(options, target, userDataDir, timing) {
-        this.options = options;
-        this.target = target;
-        this.userDataDir = userDataDir;
-        this.process = new ElectronLaunchProcess(userDataDir);
-        this.startedAtMs = timing.startedAtMs;
-        this.timeoutMs = timing.timeoutMs;
-        this.deadlineMs = timing.startedAtMs + timing.timeoutMs;
-        this.appArgs = options.appArgs ?? [];
-    }
-    diagnostics(observation) {
-        return {
-            ...observation,
-            elapsedMs: Math.max(0, Date.now() - this.startedAtMs),
-            exitCode: this.process.exitCode,
-            exitSignal: this.process.exitSignal,
-            outputCaptured: this.process.outputCaptured,
-            pid: this.process.child?.pid,
-            pidAlive: this.process.child === undefined ? undefined : this.process.pidAlive(),
-            port: observation.port ?? observation.devToolsActivePort?.port,
-            timeoutMs: this.timeoutMs,
-            userDataDir: this.userDataDir,
-        };
-    }
-    async cleanupProfile(processError) {
-        try {
-            if (processError !== undefined && processError.length > 0) {
-                await preserveSecureTempDirectory(this.userDataDir);
-            }
-            else {
-                await rm(this.userDataDir, { force: true, recursive: true });
-            }
-            return undefined;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : stringifyUnknown(error);
-            return processError !== undefined && processError.length > 0
-                ? `Profile preservation failed: ${message}`
-                : message;
-        }
-    }
-    async fail(reason, detail, observation = {}) {
-        const diagnostics = this.diagnostics(observation);
-        const processError = await this.process.terminate();
-        const output = await this.process.readOutput();
-        const profileError = await this.cleanupProfile(processError);
-        const cleanupErrors = [processError, this.process.cleanupError, profileError].filter((value) => value !== undefined);
-        const cleanupError = cleanupErrors.join("; ");
-        return {
-            ok: false,
-            failure: {
-                appArgs: this.appArgs,
-                cleanupError: cleanupError.length === 0 ? undefined : cleanupError,
-                diagnostics: { ...diagnostics, ...output.evidence },
-                error: [launchFailureMessage(reason, this.target, detail), ...output.lines].join("\n"),
-                reason,
-                target: this.target,
-                userDataDir: this.userDataDir,
-            },
-        };
-    }
-    record(port, version) {
-        const pid = this.process.child?.pid;
-        return {
-            appName: this.target.name,
-            appPath: this.target.appPath,
-            bundleId: this.target.bundleId,
-            cleanupState: "active",
-            createdAtMs: Date.now(),
-            desktopId: this.target.desktopId,
-            executablePath: this.target.executablePath,
-            launchId: `electron-${randomUUID()}`,
-            launchedByWrapper: true,
-            packageSource: this.target.packageSource,
-            pid,
-            platform: this.target.platform,
-            port,
-            processGroupId: process.platform === "win32" ? undefined : pid,
-            targetType: this.options.targetType,
-            userDataDir: this.userDataDir,
-            version: ELECTRON_LAUNCH_RECORD_VERSION,
-            webSocketDebuggerUrl: version.webSocketDebuggerUrl,
-        };
-    }
-    async run() {
-        const args = [
-            ...this.appArgs,
-            `--user-data-dir=${this.userDataDir}`,
-            "--remote-debugging-port=0",
-            ...DEFAULT_APP_ARGS,
-        ];
-        await this.process.spawn(this.target.executablePath, args, this.options.signal);
-        if (this.process.child === undefined) {
-            return this.fail(isElectronLaunchAborted(this.options.signal) ? "aborted" : "spawn-error", this.process.spawnError?.message);
-        }
-        const portResult = await pollDevToolsActivePort({
-            deadlineMs: this.deadlineMs,
-            getChildExit: this.process.childExit,
-            getSpawnError: this.process.childSpawnError,
-            signal: this.options.signal,
-            userDataDir: this.userDataDir,
-        });
-        if (portResult.port === undefined) {
-            return this.fail(portResult.failure ?? "timeout", portResult.spawnError?.message, {
-                devToolsActivePort: portResult.devToolsActivePort,
-            });
-        }
-        return this.connect(portResult.port, portResult.devToolsActivePort);
-    }
-    async connect(port, devToolsActivePort) {
-        const metadataResult = await pollCdpMetadata(port, this.deadlineMs, this.options.signal);
-        if (metadataResult.aborted) {
-            return this.fail("aborted", undefined, { devToolsActivePort, port });
-        }
-        const metadata = metadataResult.metadata;
-        if (metadata === undefined) {
-            return this.fail("port-not-found", undefined, {
-                cdpVersionReached: false,
-                devToolsActivePort,
-                port,
-            });
-        }
-        const child = this.process.child;
-        if (child === undefined) {
-            throw new Error("Electron launch lost its child handle before handoff.");
-        }
-        return {
-            ok: true,
-            value: {
-                appArgs: this.appArgs,
-                child,
-                connectArg: selectConnectArg(port, metadata, this.options.targetType),
-                record: this.record(port, metadata.version),
-                target: this.target,
-                targets: metadata.targets,
-                version: metadata.version,
-            },
-        };
-    }
-}
-async function abortedProfileResult(userDataDir, options, target) {
-    let cleanupError;
-    try {
-        await rm(userDataDir, { force: true, recursive: true });
-    }
-    catch (error) {
-        cleanupError = error instanceof Error ? error.message : stringifyUnknown(error);
-    }
-    return {
-        ok: false,
-        failure: {
-            appArgs: options.appArgs ?? [],
-            cleanupError,
-            error: launchFailureMessage("aborted", target),
-            reason: "aborted",
-            target,
-            userDataDir,
-        },
-    };
-}
-export async function launchElectronApp(options) {
-    const appArgs = options.appArgs ?? [];
-    if (isElectronLaunchAborted(options.signal)) {
-        return {
-            ok: false,
-            failure: { appArgs, error: launchFailureMessage("aborted", undefined), reason: "aborted" },
-        };
-    }
-    const target = await resolveLaunchTarget(options);
-    if (isElectronLaunchAborted(options.signal)) {
-        return {
-            ok: false,
-            failure: {
-                appArgs,
-                error: launchFailureMessage("aborted", target),
-                reason: "aborted",
-                target,
-            },
-        };
-    }
-    if (target === undefined) {
-        return {
-            ok: false,
-            failure: {
-                appArgs,
-                error: launchFailureMessage("non-electron-target", undefined),
-                reason: "non-electron-target",
-            },
-        };
-    }
-    const policy = evaluateLaunchPolicy(options, target);
-    if (policy !== undefined) {
-        return {
-            ok: false,
-            failure: {
-                appArgs,
-                error: launchFailureMessage("policy-blocked", target, policy.message),
-                policy,
-                reason: "policy-blocked",
-                target,
-            },
-        };
-    }
-    const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
-    const startedAtMs = Date.now();
-    const userDataDir = await createSecureTempDirectory(ELECTRON_PROFILE_DIR_PREFIX);
-    if (isElectronLaunchAborted(options.signal)) {
-        return abortedProfileResult(userDataDir, options, target);
-    }
-    return new ElectronLaunchAttempt(options, target, userDataDir, { timeoutMs, startedAtMs }).run();
-}

package/dist/extensions/agent-browser/lib/executable-path.js

@@ -1,29 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import { access, stat } from "node:fs/promises";
-import { delimiter, join } from "node:path";
-async function isExecutableFile(candidate) {
-    try {
-        await access(candidate, fsConstants.X_OK);
-        return (await stat(candidate)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function executableExistsOnPath(command) {
-    const extensions = process.platform === "win32"
-        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
-        : [""];
-    const candidates = (process.env.PATH ?? "")
-        .split(delimiter)
-        .filter(Boolean)
-        .flatMap((directory) => extensions.map((extension) => join(directory, `${command}${extension}`)));
-    for (const candidate of candidates) {
-        // Respect PATH/PATHEXT precedence and stop probing after the first executable.
-        // oxlint-disable-next-line no-await-in-loop
-        if (await isExecutableFile(candidate)) {
-            return true;
-        }
-    }
-    return false;
-}

package/dist/extensions/agent-browser/lib/execution-cwd.js

@@ -1,67 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { dirname, isAbsolute, join } from "node:path";
-import { isRecord } from "./parsing.js";
-function isDirectoryOwner(source) {
-    if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source)) {
-        return true;
-    }
-    const directories = [source.baseDir, isAbsolute(source.path) ? dirname(source.path) : undefined];
-    return directories.some((directory) => {
-        if (directory === undefined || directory.length === 0 || !isAbsolute(directory)) {
-            return false;
-        }
-        try {
-            const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
-            return isRecord(manifest) && manifest.name === "pi-change-working-dir";
-        }
-        catch {
-            return false;
-        }
-    });
-}
-function validateDirectoryReply(result) {
-    const invalid = "pi-change-working-dir returned an invalid execution directory. Update the extension and restart Pi.";
-    if (!isRecord(result) || Array.isArray(result)) {
-        throw new Error(invalid);
-    }
-    if (result.error !== undefined) {
-        throw new Error(typeof result.error === "string" && result.error.length > 0 ? result.error : invalid);
-    }
-    if (typeof result.cwd !== "string" || !isAbsolute(result.cwd) || result.cwd.includes("\0")) {
-        throw new Error(invalid);
-    }
-    return result.cwd;
-}
-/** The synchronous owner reply is captured before any browser policy, queue, or child await. */
-export function resolveExecutionCwd(pi, ctx) {
-    const request = {
-        sessionManager: ctx.sessionManager,
-    };
-    pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
-    const result = request.result;
-    if (result !== undefined) {
-        return validateDirectoryReply(result);
-    }
-    if (pi
-        .getAllTools()
-        .some((tool) => tool.name === "change_dir" && isDirectoryOwner(tool.sourceInfo)) ||
-        pi
-            .getCommands()
-            .some((command) => /^cwd(?::\d+)?$/.test(command.name) && isDirectoryOwner(command.sourceInfo))) {
-        throw new Error("Update pi-change-working-dir and restart Pi to use agent_browser with the selected working directory.");
-    }
-    return ctx.cwd;
-}
-export function getBrowserCwdError(cwd) {
-    try {
-        if (statSync(cwd).isDirectory()) {
-            return undefined;
-        }
-    }
-    catch (error) {
-        if (!isRecord(error) || (error.code !== "ENOENT" && error.code !== "ENOTDIR")) {
-            throw error;
-        }
-    }
-    return `Browser launch directory is unavailable: ${cwd}. Restore that directory, or explicitly use sessionMode: "fresh" without --session, or --config from the selected execution directory. The existing browser was left untouched.`;
-}

package/dist/extensions/agent-browser/lib/fs-utils.js

@@ -1,18 +0,0 @@
-import { access, stat } from "node:fs/promises";
-export async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function directoryExists(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/extensions/agent-browser/lib/input-modes/electron.js

@@ -1,201 +0,0 @@
-import { isRecord } from "../parsing.js";
-import { isStringArray } from "./shared.js";
-import { AGENT_BROWSER_ELECTRON_ACTIONS, AGENT_BROWSER_ELECTRON_HANDOFFS, AGENT_BROWSER_ELECTRON_LIST_FIELDS, AGENT_BROWSER_ELECTRON_PROBE_FIELDS, AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS, AGENT_BROWSER_ELECTRON_TARGET_TYPES, } from "./types.js";
-function optionalString(input, fieldName) {
-    const value = input[fieldName];
-    if (value === undefined) {
-        return {};
-    }
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return { error: `electron.${fieldName} must be a non-empty string when provided.` };
-    }
-    return { value: value.trim() };
-}
-function optionalInteger(input, fieldName) {
-    const value = input[fieldName];
-    if (value === undefined) {
-        return {};
-    }
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        return { error: `electron.${fieldName} must be a positive integer when provided.` };
-    }
-    return { value };
-}
-function stringArray(value) {
-    if (!isStringArray(value)) {
-        return undefined;
-    }
-    return value.map((item) => item.trim());
-}
-function arrayError(input, fieldName) {
-    const value = input[fieldName];
-    if (value === undefined) {
-        return undefined;
-    }
-    const parsed = stringArray(value);
-    return parsed === undefined || parsed.some((item) => item.length === 0)
-        ? `electron.${fieldName} must be an array of non-empty strings when provided.`
-        : undefined;
-}
-function enumError(input, fieldName, values) {
-    const value = input[fieldName];
-    if (value === undefined) {
-        return undefined;
-    }
-    return typeof value !== "string" || !values.includes(value)
-        ? `electron.${fieldName} must be one of: ${values.join(", ")}.`
-        : undefined;
-}
-function commonError(input) {
-    for (const field of ["query", "appPath", "appName", "bundleId", "executablePath", "launchId"]) {
-        const error = optionalString(input, field).error;
-        if (error !== undefined) {
-            return error;
-        }
-    }
-    for (const field of ["appArgs", "allow", "deny"]) {
-        const error = arrayError(input, field);
-        if (error !== undefined) {
-            return error;
-        }
-    }
-    return (enumError(input, "handoff", AGENT_BROWSER_ELECTRON_HANDOFFS) ??
-        enumError(input, "targetType", AGENT_BROWSER_ELECTRON_TARGET_TYPES) ??
-        numericError(input));
-}
-function numericError(input) {
-    for (const field of ["maxResults", "timeoutMs"]) {
-        const error = optionalInteger(input, field).error;
-        if (error !== undefined) {
-            return error;
-        }
-    }
-    return input.all !== undefined && input.all !== true
-        ? "electron.all must be true when provided."
-        : undefined;
-}
-function unsupportedField(input, allowed) {
-    return Object.keys(input).find((field) => !allowed.includes(field));
-}
-function allowedFieldError(input, action, allowed) {
-    const field = unsupportedField(input, allowed);
-    return field === undefined ? undefined : `electron.${action} does not support electron.${field}.`;
-}
-function compileLaunch(input) {
-    const fieldError = allowedFieldError(input, "launch", [
-        "action",
-        "allow",
-        "appArgs",
-        "appName",
-        "appPath",
-        "bundleId",
-        "deny",
-        "executablePath",
-        "handoff",
-        "targetType",
-        "timeoutMs",
-    ]);
-    if (fieldError !== undefined) {
-        return { error: fieldError };
-    }
-    const appArgs = stringArray(input.appArgs);
-    const reservedArg = appArgs?.find((arg) => arg === "--" ||
-        AGENT_BROWSER_ELECTRON_RESERVED_APP_ARGS.some((reserved) => arg === reserved || arg.startsWith(`${reserved}=`)));
-    if (reservedArg !== undefined) {
-        return { error: `electron.appArgs must not include wrapper-owned launch flag ${reservedArg}.` };
-    }
-    const providedTargets = ["appPath", "appName", "bundleId", "executablePath"].filter((field) => input[field] !== undefined);
-    if (providedTargets.length !== 1) {
-        return {
-            error: "electron.launch requires exactly one of appPath, appName, bundleId, or executablePath.",
-        };
-    }
-    return {
-        compiled: {
-            action: "launch",
-            allow: stringArray(input.allow),
-            appArgs,
-            deny: stringArray(input.deny),
-            appName: optionalString(input, "appName").value,
-            appPath: optionalString(input, "appPath").value,
-            bundleId: optionalString(input, "bundleId").value,
-            executablePath: optionalString(input, "executablePath").value,
-            handoff: AGENT_BROWSER_ELECTRON_HANDOFFS.find((value) => value === input.handoff) ?? "snapshot",
-            targetType: AGENT_BROWSER_ELECTRON_TARGET_TYPES.find((value) => value === input.targetType) ?? "page",
-            timeoutMs: optionalInteger(input, "timeoutMs").value,
-        },
-    };
-}
-function compileList(input) {
-    const field = unsupportedField(input, AGENT_BROWSER_ELECTRON_LIST_FIELDS);
-    if (field !== undefined) {
-        return { error: `electron.list only supports query and maxResults; remove electron.${field}.` };
-    }
-    return {
-        compiled: {
-            action: "list",
-            maxResults: optionalInteger(input, "maxResults").value,
-            query: optionalString(input, "query").value,
-        },
-    };
-}
-function compileProbe(input) {
-    const field = unsupportedField(input, AGENT_BROWSER_ELECTRON_PROBE_FIELDS);
-    if (field !== undefined) {
-        return {
-            error: `electron.probe only supports action, launchId, and timeoutMs; remove electron.${field}.`,
-        };
-    }
-    const launchId = optionalString(input, "launchId").value;
-    const timeoutMs = optionalInteger(input, "timeoutMs").value;
-    return {
-        compiled: {
-            action: "probe",
-            ...(launchId !== undefined ? { launchId } : {}),
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        },
-    };
-}
-function compileStatusOrCleanup(input, action) {
-    const error = allowedFieldError(input, action, ["action", "all", "launchId", "timeoutMs"]);
-    if (error !== undefined) {
-        return { error };
-    }
-    if (input.all === true && input.launchId !== undefined) {
-        return { error: `electron.${action} accepts launchId or all, not both.` };
-    }
-    return {
-        compiled: {
-            action,
-            all: input.all === true ? true : undefined,
-            launchId: optionalString(input, "launchId").value,
-            timeoutMs: optionalInteger(input, "timeoutMs").value,
-        },
-    };
-}
-export function compileAgentBrowserElectron(input) {
-    if (!isRecord(input)) {
-        return { error: "electron must be an object." };
-    }
-    const action = AGENT_BROWSER_ELECTRON_ACTIONS.find((value) => value === input.action);
-    if (action === undefined) {
-        return {
-            error: `electron.action must be one of: ${AGENT_BROWSER_ELECTRON_ACTIONS.join(", ")}.`,
-        };
-    }
-    const error = commonError(input);
-    if (error !== undefined) {
-        return { error };
-    }
-    switch (action) {
-        case "launch":
-            return compileLaunch(input);
-        case "list":
-            return compileList(input);
-        case "probe":
-            return compileProbe(input);
-        case "status":
-        case "cleanup":
-            return compileStatusOrCleanup(input, action);
-    }
-}