@abot-ai/runtime 1.3.0 → 1.4.0

package/dist/plugins/system/source/application-catalog.d.ts

@@ -0,0 +1,14 @@
+import { type SystemApplication, type SystemProcessRunner, type SystemTarget } from "./contracts.js";
+export type SystemApplicationCatalogScope = Readonly<{
+    source: "windows_start_apps" | "macos_application_bundles" | "linux_desktop_entries";
+    roots: readonly string[];
+    includesExecutableSearch: false;
+    includesOtherTargets: false;
+}>;
+export type SystemApplicationCatalog = Readonly<{
+    applications: readonly SystemApplication[];
+    complete: boolean;
+    scope: SystemApplicationCatalogScope;
+}>;
+export declare function parseDesktopApplication(content: string, path: string): SystemApplication | undefined;
+export declare function readSystemApplications(target: SystemTarget, run: SystemProcessRunner): Promise<SystemApplicationCatalog>;

package/dist/plugins/system/source/application-catalog.js

@@ -0,0 +1,185 @@
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { SystemOperationError, } from "./contracts.js";
+import { powershellArguments } from "./targets.js";
+const CATALOG_ENTRY_LIMIT = 2_000;
+function isAbsentOptionalCatalogRoot(error, depth) {
+    if (depth !== 0 || !(error instanceof Error))
+        return false;
+    return "code" in error && error.code === "ENOENT";
+}
+async function readApplicationDirectory(path, depth) {
+    try {
+        return {
+            entries: await readdir(path, { withFileTypes: true }),
+            complete: true,
+        };
+    }
+    catch (error) {
+        return { entries: [], complete: isAbsentOptionalCatalogRoot(error, depth) };
+    }
+}
+async function collectApplicationPaths(roots, extension) {
+    const pending = roots.map((path) => ({ path, depth: 0 }));
+    const paths = [];
+    let scannedEntries = 0;
+    let complete = true;
+    while (pending.length > 0 &&
+        scannedEntries < 20_000 &&
+        paths.length < CATALOG_ENTRY_LIMIT) {
+        const current = pending.shift();
+        const directory = await readApplicationDirectory(current.path, current.depth);
+        complete = complete && directory.complete;
+        for (const entry of directory.entries) {
+            scannedEntries += 1;
+            if (scannedEntries >= 20_000 || paths.length >= CATALOG_ENTRY_LIMIT) {
+                complete = false;
+                break;
+            }
+            const absolute = join(current.path, entry.name);
+            if (entry.name.endsWith(extension)) {
+                paths.push(absolute);
+                continue;
+            }
+            if (!entry.isDirectory())
+                continue;
+            if (current.depth >= 4) {
+                complete = false;
+                continue;
+            }
+            pending.push({ path: absolute, depth: current.depth + 1 });
+        }
+    }
+    return {
+        paths: [...new Set(paths)].sort(),
+        complete: complete && pending.length === 0,
+    };
+}
+export function parseDesktopApplication(content, path) {
+    const section = content
+        .split(/^\[Desktop Entry\]\s*$/mu)[1]
+        ?.split(/^\[/mu)[0];
+    if (!section)
+        return undefined;
+    const fields = new Map(section.split(/\r?\n/u).map((line) => {
+        const split = line.indexOf("=");
+        return [
+            line.slice(0, split).trim(),
+            line.slice(split + 1).trim(),
+        ];
+    }));
+    if (fields.get("Type") !== "Application")
+        return undefined;
+    if (fields.get("Hidden") === "true")
+        return undefined;
+    const name = fields.get("Name");
+    if (!name)
+        return undefined;
+    return { id: path, name, target: "linux" };
+}
+async function windowsApplications(target, run) {
+    const result = await run({
+        executable: target.shell,
+        args: powershellArguments("@(Get-StartApps | Sort-Object AppID | Select-Object -First 2001 Name,AppID) | ConvertTo-Json -Compress"),
+        timeoutMs: 15_000,
+        outputMaxChars: 512_000,
+    });
+    if (result.status !== "completed" ||
+        result.exitCode !== 0 ||
+        result.outputTruncated)
+        throw new SystemOperationError("system_application_catalog_unavailable", "Windows Start application catalog could not be read completely within the observation budget.");
+    let entries;
+    try {
+        entries = JSON.parse(result.stdout || "[]");
+    }
+    catch {
+        throw new SystemOperationError("system_application_catalog_invalid", "Windows returned an unreadable application catalog.");
+    }
+    const rows = Array.isArray(entries) ? entries : [entries];
+    const applications = rows
+        .slice(0, CATALOG_ENTRY_LIMIT)
+        .flatMap((entry) => {
+        if (!entry || typeof entry !== "object")
+            return [];
+        if (!("Name" in entry) || !("AppID" in entry))
+            return [];
+        if (typeof entry.Name !== "string" || typeof entry.AppID !== "string")
+            return [];
+        return [
+            { id: entry.AppID, name: entry.Name, target: "windows" },
+        ];
+    });
+    return {
+        applications,
+        complete: rows.length <= CATALOG_ENTRY_LIMIT,
+        scope: {
+            source: "windows_start_apps",
+            roots: [],
+            includesExecutableSearch: false,
+            includesOtherTargets: false,
+        },
+    };
+}
+export async function readSystemApplications(target, run) {
+    if (target.id === "windows")
+        return windowsApplications(target, run);
+    if (target.id === "macos") {
+        const roots = [
+            "/Applications",
+            "/System/Applications",
+            join(homedir(), "Applications"),
+        ];
+        const catalog = await collectApplicationPaths(roots, ".app");
+        return {
+            applications: catalog.paths.map((id) => ({
+                id,
+                name: basename(id, ".app"),
+                target: "macos",
+            })),
+            complete: catalog.complete,
+            scope: {
+                source: "macos_application_bundles",
+                roots,
+                includesExecutableSearch: false,
+                includesOtherTargets: false,
+            },
+        };
+    }
+    const dataHome = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+    const dataDirs = (process.env.XDG_DATA_DIRS ?? "/usr/local/share:/usr/share").split(":");
+    const roots = [dataHome, ...dataDirs].map((directory) => join(directory, "applications"));
+    const catalog = await collectApplicationPaths(roots, ".desktop");
+    const applications = [];
+    let complete = catalog.complete;
+    for (const path of catalog.paths) {
+        let content;
+        try {
+            content = await readFile(path, "utf8");
+        }
+        catch {
+            complete = false;
+            continue;
+        }
+        if (isDesktopEntryOverBudget(content)) {
+            complete = false;
+            continue;
+        }
+        const application = parseDesktopApplication(content, path);
+        if (application)
+            applications.push(application);
+    }
+    return {
+        applications,
+        complete,
+        scope: {
+            source: "linux_desktop_entries",
+            roots,
+            includesExecutableSearch: false,
+            includesOtherTargets: false,
+        },
+    };
+}
+function isDesktopEntryOverBudget(content) {
+    return content.length > 128_000;
+}

package/dist/plugins/system/source/application-launch.d.ts

@@ -0,0 +1,10 @@
+import { type SystemApplication, type SystemProcessResult, type SystemProcessRunner, type SystemTarget } from "./contracts.js";
+export declare function launchSystemApplication(input: {
+    target: SystemTarget;
+    params: Record<string, unknown>;
+    run: SystemProcessRunner;
+    abortSignal?: AbortSignal;
+}): Promise<{
+    application: SystemApplication;
+    process: SystemProcessResult;
+}>;

package/dist/plugins/system/source/application-launch.js

@@ -0,0 +1,80 @@
+import { readRequiredString } from "../../../src/plugin-sdk/index.js";
+import { readSystemApplications } from "./application-catalog.js";
+import { SystemOperationError, } from "./contracts.js";
+import { findExecutable, powershellArguments, powershellLiteral, } from "./targets.js";
+function readApplicationArguments(value) {
+    if (value === undefined)
+        return [];
+    if (!hasBoundedArgumentArray(value))
+        throw new SystemOperationError("system_application_arguments_invalid", "arguments must be an array of at most 32 strings.");
+    for (const argument of value) {
+        if (!isSupportedApplicationArgument(argument))
+            throw new SystemOperationError("system_application_arguments_invalid", "Each application argument must be a string without null bytes, at most 4096 characters.");
+    }
+    return [...value];
+}
+export async function launchSystemApplication(input) {
+    const { target, params, run } = input;
+    const id = readRequiredString(params.application_id, {
+        name: "application_id",
+        maxLength: 4_096,
+    });
+    const args = readApplicationArguments(params.arguments);
+    const catalog = await readSystemApplications(target, run);
+    const application = catalog.applications.find((entry) => entry.id === id);
+    if (!application)
+        throw new SystemOperationError("system_application_not_found", "The identity is absent from the current target catalog; this does not establish that the application is uninstalled. Inspect the correct OS target and use system_command for bounded executable discovery when this catalog is insufficient.");
+    const common = {
+        timeoutMs: 30_000,
+        ...(input.abortSignal ? { abortSignal: input.abortSignal } : {}),
+    };
+    if (target.id === "macos")
+        return {
+            application,
+            process: await run({
+                ...common,
+                executable: "/usr/bin/open",
+                args: ["-a", id, ...(args.length ? ["--args", ...args] : [])],
+            }),
+        };
+    if (hasUnsupportedTargetArguments(target, args))
+        throw new SystemOperationError("system_application_arguments_unsupported", "This target application catalog does not define generic raw arguments. Use system_command with the application's documented native invocation.");
+    if (target.id === "windows") {
+        return {
+            application,
+            process: await run({
+                ...common,
+                executable: target.shell,
+                args: powershellArguments(`$applicationPath=${powershellLiteral("shell:AppsFolder\\" + id)}; Start-Process -FilePath (Join-Path $env:SystemRoot 'explorer.exe') -ArgumentList ('"' + $applicationPath + '"'); Write-Output 'Launch request dispatched to Windows shell.'`),
+            }),
+        };
+    }
+    const launcher = await findExecutable("gio");
+    if (!launcher)
+        throw new SystemOperationError("system_application_launcher_unavailable", "The installed desktop application catalog was read, but a native gio launcher is unavailable.");
+    return {
+        application,
+        process: await run({
+            ...common,
+            executable: launcher,
+            args: ["launch", id],
+        }),
+    };
+}
+function hasBoundedArgumentArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.length <= 32;
+}
+function isSupportedApplicationArgument(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length > 4_096)
+        return false;
+    return !value.includes("\0");
+}
+function hasUnsupportedTargetArguments(target, args) {
+    if (target.id === "macos")
+        return false;
+    return args.length > 0;
+}

package/dist/plugins/system/source/application-observation.d.ts

@@ -0,0 +1,25 @@
+import type { SystemApplicationCatalog } from "./application-catalog.js";
+import type { SystemTarget } from "./contracts.js";
+export declare function systemApplicationObservation(target: SystemTarget, catalog: SystemApplicationCatalog, query: string, limit: number): {
+    output: string;
+    data: {
+        target: import("./contracts.js").SystemTargetId;
+        transport: "native" | "wsl_interop";
+        absenceConclusionSupported: boolean;
+        completenessMeaning: string;
+        catalogScope: Readonly<{
+            source: "windows_start_apps" | "macos_application_bundles" | "linux_desktop_entries";
+            roots: readonly string[];
+            includesExecutableSearch: false;
+            includesOtherTargets: false;
+        }>;
+        catalogComplete: boolean;
+        observedMatches: number;
+        omittedMatches: number;
+        applications: Readonly<{
+            id: string;
+            name: string;
+            target: import("./contracts.js").SystemTargetId;
+        }>[];
+    };
+};

package/dist/plugins/system/source/application-observation.js

@@ -0,0 +1,53 @@
+const SUMMARY_MAX_CHARS = 7_000;
+const SUMMARY_ROOT_LIMIT = 16;
+const SUMMARY_ROOT_CHARS = 256;
+export function systemApplicationObservation(target, catalog, query, limit) {
+    const matches = catalog.applications.filter((application) => matchesApplicationQuery(application.name, application.id, query));
+    const data = {
+        target: target.id,
+        transport: target.transport,
+        absenceConclusionSupported: false,
+        completenessMeaning: "declared_catalog_sources_only",
+        catalogScope: catalog.scope,
+        catalogComplete: catalog.complete,
+        observedMatches: matches.length,
+        omittedMatches: Math.max(0, matches.length - limit),
+        applications: matches.slice(0, limit),
+    };
+    const summaryRoots = catalog.scope.roots
+        .slice(0, SUMMARY_ROOT_LIMIT)
+        .map((root) => root.slice(0, SUMMARY_ROOT_CHARS));
+    const summary = {
+        ...data,
+        catalogScope: { ...catalog.scope, roots: summaryRoots },
+        summaryRootsOmitted: Math.max(0, catalog.scope.roots.length - summaryRoots.length),
+        summaryRootCharactersOmitted: catalog.scope.roots.reduce((total, root, index) => total + root.length - (summaryRoots[index]?.length ?? 0), 0),
+        applications: [...data.applications],
+        summaryApplicationsOmitted: 0,
+    };
+    while (isApplicationSummaryOverBudget(summary)) {
+        summary.applications.pop();
+        summary.summaryApplicationsOmitted += 1;
+    }
+    while (isCatalogRootSummaryOverBudget(summary)) {
+        const removedRoot = summary.catalogScope.roots.pop();
+        summary.summaryRootsOmitted += 1;
+        summary.summaryRootCharactersOmitted += removedRoot.length;
+    }
+    return { output: JSON.stringify(summary), data };
+}
+function matchesApplicationQuery(name, id, query) {
+    if (name.toLowerCase().includes(query))
+        return true;
+    return id.toLowerCase().includes(query);
+}
+function isApplicationSummaryOverBudget(summary) {
+    if (summary.applications.length === 0)
+        return false;
+    return JSON.stringify(summary).length > SUMMARY_MAX_CHARS;
+}
+function isCatalogRootSummaryOverBudget(summary) {
+    if (summary.catalogScope.roots.length === 0)
+        return false;
+    return JSON.stringify(summary).length > SUMMARY_MAX_CHARS;
+}

package/dist/plugins/system/source/commands.d.ts

@@ -0,0 +1,7 @@
+import { type SystemProcessResult, type SystemProcessRunner, type SystemTarget } from "./contracts.js";
+export declare function executeSystemCommand(input: {
+    target: SystemTarget;
+    params: Record<string, unknown>;
+    run: SystemProcessRunner;
+    abortSignal?: AbortSignal;
+}): Promise<SystemProcessResult>;

package/dist/plugins/system/source/commands.js

@@ -0,0 +1,71 @@
+import { stat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { readBoundedInteger, readRequiredString, } from "../../../src/plugin-sdk/index.js";
+import { SystemOperationError, } from "./contracts.js";
+import { elevatedSystemCommand } from "./elevation.js";
+import { powershellArguments, windowsSystemCommandScript } from "./targets.js";
+export async function executeSystemCommand(input) {
+    const { target, params, run } = input;
+    const command = readRequiredString(params.command, {
+        name: "command",
+        trim: false,
+        maxLength: 4_096,
+    });
+    const cwd = readRequiredString(params.cwd, { name: "cwd", maxLength: 4_096 });
+    const timeoutMs = params.timeout_ms === undefined
+        ? 60_000
+        : readBoundedInteger(params.timeout_ms, {
+            name: "timeout_ms",
+            minimum: 1_000,
+            maximum: 600_000,
+        });
+    if (hasSystemCommandNullBytes(command, cwd))
+        throw new SystemOperationError("system_command_invalid", "Commands and directories cannot contain null bytes.");
+    if (hasInvalidElevationFlag(params.elevated))
+        throw new SystemOperationError("system_command_invalid", "elevated must be a boolean.");
+    const absoluteCwd = target.id === "windows"
+        ? hasExplicitWindowsDirectory(cwd)
+        : isAbsolute(cwd);
+    if (!absoluteCwd)
+        throw new SystemOperationError("system_cwd_invalid", "System commands require an explicit absolute directory in the selected OS namespace.");
+    await requireNativeWorkingDirectory(target, cwd);
+    const plan = params.elevated === true
+        ? await elevatedSystemCommand({ target, command, cwd, run })
+        : unprivilegedSystemCommand(target, command, cwd);
+    return run({
+        ...plan,
+        timeoutMs,
+        ...(input.abortSignal ? { abortSignal: input.abortSignal } : {}),
+    });
+}
+function unprivilegedSystemCommand(target, command, cwd) {
+    if (target.id === "windows")
+        return {
+            executable: target.shell,
+            args: powershellArguments(windowsSystemCommandScript(command, cwd)),
+        };
+    return { executable: target.shell, args: ["-lc", command], cwd };
+}
+function hasExplicitWindowsDirectory(path) {
+    if (/^[a-z]:[\\/]/iu.test(path))
+        return true;
+    return /^\\\\[^\\/]+[\\/][^\\/]+(?:[\\/]|$)/u.test(path);
+}
+function hasSystemCommandNullBytes(command, cwd) {
+    if (command.includes("\0"))
+        return true;
+    return cwd.includes("\0");
+}
+function hasInvalidElevationFlag(value) {
+    if (value === undefined)
+        return false;
+    return typeof value !== "boolean";
+}
+async function requireNativeWorkingDirectory(target, cwd) {
+    if (target.id === "windows")
+        return;
+    const directory = await stat(cwd).catch(() => undefined);
+    if (directory?.isDirectory())
+        return;
+    throw new SystemOperationError("system_cwd_unavailable", "The selected target directory is unavailable or not a directory.");
+}

package/dist/plugins/system/source/companion/autostart.d.ts

@@ -0,0 +1,16 @@
+export type NativeAutostartOptions = Readonly<{
+    platform: NodeJS.Platform;
+    homeDir: string;
+    appData?: string;
+    uid?: number;
+    nodePath: string;
+    cliPath: string;
+    stateDir: string;
+    execute?: (file: string, args: readonly string[]) => Promise<void>;
+}>;
+export declare function nativeAutostartFile(options: NativeAutostartOptions): string;
+export declare function renderNativeAutostart(options: NativeAutostartOptions): string;
+export declare function installNativeAutostart(options: NativeAutostartOptions): Promise<{
+    started: boolean;
+}>;
+export declare function uninstallNativeAutostart(options: NativeAutostartOptions): Promise<void>;

package/dist/plugins/system/source/companion/autostart.js

@@ -0,0 +1,146 @@
+import { execFile } from "node:child_process";
+import { lstat, mkdir, readFile, rename, unlink, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
+const executeFile = promisify(execFile);
+const LABEL = "com.abot.host-companion";
+const OWNER_MARKER = "ABot managed native host companion";
+function xmlText(value) {
+    return value.replace(/[&<>"']/gu, (character) => ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&apos;",
+    })[character]);
+}
+function windowsArgument(value) {
+    if (/["\r\n\0]/u.test(value))
+        throw new Error("Unsupported native startup path.");
+    return `"${value}"`;
+}
+function vbsString(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+export function nativeAutostartFile(options) {
+    if (options.platform === "darwin")
+        return join(options.homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
+    if (options.platform !== "win32")
+        throw new Error("Automatic host startup supports Windows and macOS only.");
+    if (!options.appData)
+        throw new Error("Windows APPDATA is unavailable for current-user startup.");
+    return join(options.appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "ABot Host Companion.vbs");
+}
+export function renderNativeAutostart(options) {
+    if (options.platform === "win32") {
+        const command = `${windowsArgument(options.nodePath)} ${windowsArgument(options.cliPath)} host run`;
+        return [
+            `' ${OWNER_MARKER}`,
+            'Set shell = CreateObject("WScript.Shell")',
+            `shell.Run ${vbsString(command)}, 0, False`,
+            "",
+        ].join("\r\n");
+    }
+    if (options.platform !== "darwin")
+        throw new Error("Automatic host startup supports Windows and macOS only.");
+    const argumentsXml = [options.nodePath, options.cliPath, "host", "run"]
+        .map((argument) => `<string>${xmlText(argument)}</string>`)
+        .join("");
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<!-- ${OWNER_MARKER} -->\n<plist version="1.0"><dict>
+<key>Label</key><string>${LABEL}</string>
+<key>ProgramArguments</key><array>${argumentsXml}</array>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+<key>LimitLoadToSessionType</key><string>Aqua</string>
+<key>ProcessType</key><string>Interactive</string>
+<key>WorkingDirectory</key><string>${xmlText(options.homeDir)}</string>
+<key>StandardOutPath</key><string>${xmlText(join(options.stateDir, "agent.log"))}</string>
+<key>StandardErrorPath</key><string>${xmlText(join(options.stateDir, "agent.log"))}</string>
+</dict></plist>\n`;
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? error.code
+        : undefined;
+}
+async function existingOwnedRegistration(path) {
+    const stat = await lstat(path).catch((error) => {
+        if (errorCode(error) === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return false;
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16_384)
+        throw new Error("Refusing to change an unexpected host startup registration.");
+    if (!(await readFile(path, "utf8")).includes(OWNER_MARKER))
+        throw new Error("The host startup path belongs to an unmanaged file.");
+    return true;
+}
+async function execute(options, file, args) {
+    if (options.execute)
+        return options.execute(file, args);
+    await executeFile(file, [...args], {
+        windowsHide: true,
+        timeout: 10_000,
+        maxBuffer: 16_384,
+    });
+}
+function macUserDomain(options) {
+    if (!Number.isInteger(options.uid))
+        throw new Error("The macOS GUI user identity is unavailable.");
+    return `gui/${options.uid}`;
+}
+async function unloadMacRegistration(options) {
+    try {
+        await execute(options, "/bin/launchctl", [
+            "bootout",
+            `${macUserDomain(options)}/${LABEL}`,
+        ]);
+    }
+    catch (error) {
+        if ([3, 113].includes(Number(errorCode(error))))
+            return;
+        throw error;
+    }
+}
+export async function installNativeAutostart(options) {
+    const path = nativeAutostartFile(options);
+    const existing = await existingOwnedRegistration(path);
+    if (existing && options.platform === "darwin")
+        await unloadMacRegistration(options);
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, renderNativeAutostart(options), {
+            encoding: "utf8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        await rename(temporary, path);
+    }
+    finally {
+        await unlink(temporary).catch((error) => {
+            if (errorCode(error) !== "ENOENT")
+                throw error;
+        });
+    }
+    if (options.platform === "darwin") {
+        await execute(options, "/bin/launchctl", [
+            "bootstrap",
+            macUserDomain(options),
+            path,
+        ]);
+        return { started: true };
+    }
+    return { started: false };
+}
+export async function uninstallNativeAutostart(options) {
+    const path = nativeAutostartFile(options);
+    if (!(await existingOwnedRegistration(path)))
+        return;
+    await unlink(path);
+    if (options.platform === "darwin")
+        await unloadMacRegistration(options);
+}

package/dist/plugins/system/source/companion/broker-location.d.ts

@@ -0,0 +1,11 @@
+export type HostBrokerLocation = {
+    ownerId: string;
+    token: string;
+    socketPath: string;
+};
+export declare function readBrokerLocation(rootDir: string): HostBrokerLocation | undefined;
+export declare function createBrokerLocation(rootDir: string): HostBrokerLocation;
+/** Call only after acquiring the installation lease and listener. */
+export declare function publishBrokerLocation(rootDir: string, owner: HostBrokerLocation): void;
+/** Release the receipt before the listener, while successors cannot acquire it. */
+export declare function releaseBrokerLocation(rootDir: string, owner: HostBrokerLocation): void;