@dna113p/machines 0.1.0

package/dist/src/agent-bindings.js

@@ -0,0 +1,113 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { machinesUserHome, nearestMachinesDirectory } from "./discovery.js";
+const presetFields = new Set(["description", "runner", "harness", "model", "thinking"]);
+export async function loadAgentBindings(cwd = process.cwd(), home = machinesUserHome(), adapters = {}) {
+    const globalPath = join(home, ".machines", "agents.ts");
+    const projectDirectory = await nearestMachinesDirectory(cwd);
+    const projectPath = projectDirectory === undefined
+        ? undefined
+        : join(projectDirectory, "agents.ts");
+    const paths = projectPath === undefined || resolve(projectPath) === resolve(globalPath)
+        ? [globalPath]
+        : [globalPath, projectPath];
+    const agents = {};
+    const presets = {};
+    const sources = {};
+    for (const path of paths) {
+        if (!await isFile(path))
+            continue;
+        const bindings = await loadBindingFile(path, adapters);
+        for (const [name, preset] of Object.entries(bindings)) {
+            agents[name] = preset.runner;
+            presets[name] = preset;
+            sources[name] = path;
+        }
+    }
+    return { agents, presets, sources };
+}
+async function loadBindingFile(path, adapters) {
+    let loaded;
+    try {
+        loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(path).href));
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        throw new Error(`Could not load Agent bindings from "${path}": ${message}`, { cause });
+    }
+    const configure = loaded.default;
+    if (typeof configure !== "function") {
+        throw new Error(`Agent bindings "${path}" must default-export a function`);
+    }
+    let value;
+    try {
+        value = await configure(adapters);
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        throw new Error(`Could not configure Agent bindings from "${path}": ${message}`, { cause });
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`Agent bindings "${path}" must return an object`);
+    }
+    const bindings = {};
+    for (const [name, preset] of Object.entries(value)) {
+        if (name.trim() === "" || name !== name.trim()) {
+            throw new Error(`Agent bindings "${path}" contain a non-trimmed or empty name`);
+        }
+        if (preset === null || typeof preset !== "object" || Array.isArray(preset)) {
+            throw new Error(`Agent preset "${name}" in "${path}" must be an object`);
+        }
+        const unknownFields = Object.keys(preset).filter((field) => !presetFields.has(field));
+        if (unknownFields.length > 0) {
+            throw new Error(`Agent preset "${name}" in "${path}" has unknown fields: ${unknownFields.join(", ")}`);
+        }
+        const candidate = preset;
+        const description = oneLine(candidate.description, "description", name, path);
+        if (typeof candidate.runner !== "function") {
+            throw new Error(`Agent preset "${name}" in "${path}" must include a runner function`);
+        }
+        bindings[name] = {
+            description,
+            runner: candidate.runner,
+            ...optionalField(candidate.harness, "harness", name, path),
+            ...optionalField(candidate.model, "model", name, path),
+            ...optionalField(candidate.thinking, "thinking", name, path),
+        };
+    }
+    return bindings;
+}
+function optionalField(value, field, name, path) {
+    return value === undefined
+        ? {}
+        : { [field]: oneLine(value, field, name, path) };
+}
+function oneLine(value, field, name, path) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Agent preset "${name}" in "${path}" must have a non-empty ${field}`);
+    }
+    const normalized = value.trim();
+    if (/\r|\n|\t/u.test(normalized)) {
+        throw new Error(`Agent preset "${name}" ${field} in "${path}" must fit in one line`);
+    }
+    return normalized;
+}
+async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return false;
+        throw cause;
+    }
+}

package/dist/src/catalog.d.ts

@@ -0,0 +1,31 @@
+import { type AgentPreset } from "./agent-bindings.ts";
+import type { AgentRunner } from "./index.ts";
+export interface MachineSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly path: string;
+    readonly agentRoles: Readonly<Record<string, string>>;
+    readonly missingAgents: readonly string[];
+    readonly error?: string;
+}
+export interface AgentPresetSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly harness?: string;
+    readonly model?: string;
+    readonly thinking?: string;
+    readonly source: string;
+}
+export interface LauncherLocation {
+    readonly cwd?: string;
+    readonly home?: string;
+}
+interface ResolvedAgentPresets {
+    readonly agents: Readonly<Record<string, AgentRunner>>;
+    readonly presets: Readonly<Record<string, AgentPreset>>;
+    readonly sources: Readonly<Record<string, string>>;
+}
+export declare function inspectMachines(location?: LauncherLocation): Promise<readonly MachineSummary[]>;
+export declare function inspectAgentPresets(location?: LauncherLocation): Promise<readonly AgentPresetSummary[]>;
+export declare function configuredAgentPresets(cwd: string, home: string): Promise<ResolvedAgentPresets>;
+export {};

package/dist/src/catalog.js

@@ -0,0 +1,68 @@
+import { loadAgentBindings } from "./agent-bindings.js";
+import { acpAgent } from "./acp.js";
+import { discoverMachines, machinesUserHome } from "./discovery.js";
+import { loadMachineModule, readAgentRoles, requireMachineDescription } from "./machine-module.js";
+export async function inspectMachines(location = {}) {
+    const cwd = location.cwd ?? process.cwd();
+    const home = location.home ?? machinesUserHome();
+    const discovered = await discoverMachines(cwd, home);
+    const bindings = await configuredAgentPresets(cwd, home)
+        .then((value) => ({ value, error: undefined }), (cause) => ({ value: undefined, error: errorMessage(cause) }));
+    return Promise.all(discovered.map(async (found) => {
+        try {
+            const loaded = await loadMachineModule(found.path);
+            const description = requireMachineDescription(loaded, found.path);
+            const agentRoles = readAgentRoles(loaded, found.path);
+            if (typeof loaded.default !== "function") {
+                throw new Error(`Machine "${found.path}" must default-export a factory`);
+            }
+            return {
+                ...found,
+                description,
+                agentRoles,
+                missingAgents: Object.keys(agentRoles).filter((name) => bindings.value !== undefined && !Object.hasOwn(bindings.value.agents, name)),
+                ...(bindings.error === undefined ? {} : { error: bindings.error }),
+            };
+        }
+        catch (cause) {
+            return { ...found, description: "", agentRoles: {}, missingAgents: [], error: errorMessage(cause) };
+        }
+    }));
+}
+export async function inspectAgentPresets(location = {}) {
+    const cwd = location.cwd ?? process.cwd();
+    const home = location.home ?? machinesUserHome();
+    const configured = await configuredAgentPresets(cwd, home);
+    return Object.entries(configured.presets)
+        .map(([name, preset]) => ({
+        name,
+        description: preset.description,
+        ...(preset.harness === undefined ? {} : { harness: preset.harness }),
+        ...(preset.model === undefined ? {} : { model: preset.model }),
+        ...(preset.thinking === undefined ? {} : { thinking: preset.thinking }),
+        source: configured.sources[name] ?? "unknown",
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function configuredAgentPresets(cwd, home) {
+    const configured = await loadAgentBindings(cwd, home, { acpAgent });
+    const defaultRunner = acpAgent("npx", ["-y", "pi-acp"], {
+        harness: "pi-acp",
+        output: "capture",
+    });
+    return {
+        agents: { default: defaultRunner, ...configured.agents },
+        presets: {
+            default: {
+                description: "Runs the current Pi Agent through ACP",
+                harness: "pi-acp",
+                runner: defaultRunner,
+            },
+            ...configured.presets,
+        },
+        sources: { default: "built in", ...configured.sources },
+    };
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+import { emitKeypressEvents } from "node:readline";
+import { stripVTControlCharacters } from "node:util";
+import yoctoSpinner from "yocto-spinner";
+import { bold, cyan, dim, green, magenta, red, yellow } from "yoctocolors";
+import { discoverMachines, machinesUserHome } from "./discovery.js";
+import { listAgentPresets, listMachines, prepareMachineRun, } from "./launcher.js";
+const [command, selector, ...argumentsAfterSelector] = process.argv.slice(2);
+try {
+    if (command === "list" && selector === undefined) {
+        const machines = await listMachines({ cwd: process.cwd() });
+        if (machines.length === 0)
+            console.log("No Machines found.");
+        machines.forEach((found, index) => {
+            printMachineListing(found, index > 0);
+        });
+        if (machines.some((found) => found.error !== undefined))
+            process.exitCode = 1;
+    }
+    else if (command === "agents" && selector === undefined) {
+        const presets = await listAgentPresets({ cwd: process.cwd() });
+        if (presets.length === 0)
+            console.log("No Agent presets found.");
+        presets.forEach((preset, index) => {
+            printAgentListing(preset, index > 0);
+        });
+    }
+    else if (command === "show" && selector !== undefined) {
+        const machinePath = await resolveMachine(selector);
+        console.log(`Machine: ${machinePath}`);
+        console.log(await readFile(machinePath, "utf8"));
+    }
+    else if (command === "run" && selector !== undefined) {
+        await runMachine(await resolveMachine(selector), argumentsAfterSelector);
+    }
+    else {
+        throw new Error([
+            "Usage:",
+            "  machine list",
+            "  machine agents",
+            "  machine show <name-or-file>",
+            "  machine run <name-or-file> [--agent role=preset]... [--] [input]",
+        ].join("\n"));
+    }
+}
+catch (cause) {
+    console.error(cause instanceof Error ? cause.message : String(cause));
+    process.exitCode = 1;
+}
+async function resolveMachine(selector) {
+    if (isAbsolute(selector) || selector.includes("/") || selector.endsWith(".ts")) {
+        return resolve(selector);
+    }
+    const machines = await discoverMachines(process.cwd(), machinesUserHome());
+    const found = machines.find((candidate) => candidate.name === selector);
+    if (found === undefined) {
+        throw new Error(`Machine "${selector}" not found. Run "machine list" to see available Machines.`);
+    }
+    return found.path;
+}
+async function runMachine(machinePath, args) {
+    const invocation = parseRunArguments(args);
+    printMachineHeader(machinePath);
+    const prepared = await prepareMachineRun({
+        cwd: process.cwd(),
+        machine: machinePath,
+        input: invocation.input,
+        agents: Object.fromEntries(invocation.agentOverrides),
+    });
+    const status = createRunStatus(machinePath);
+    try {
+        const result = await prepared.start({
+            onAgentUpdate: status.onAgentUpdate,
+            onHumanInput: status.onHumanInput,
+            onState: status.onState,
+        });
+        status.succeed();
+        console.log(`--> ${String(result.value)}`);
+    }
+    catch (cause) {
+        status.fail();
+        throw cause;
+    }
+    finally {
+        status.close();
+    }
+}
+function parseRunArguments(args) {
+    const agentOverrides = new Map();
+    let index = 0;
+    while (index < args.length) {
+        const argument = args[index];
+        if (argument === "--") {
+            index += 1;
+            break;
+        }
+        if (argument !== "--agent")
+            break;
+        const assignment = args[index + 1];
+        if (assignment === undefined) {
+            throw new Error('Expected "role=preset" after "--agent"');
+        }
+        const separator = assignment.indexOf("=");
+        const role = separator === -1 ? "" : assignment.slice(0, separator);
+        const preset = separator === -1 ? "" : assignment.slice(separator + 1);
+        if (role.trim() === ""
+            || preset.trim() === ""
+            || role !== role.trim()
+            || preset !== preset.trim()) {
+            throw new Error(`Invalid Agent override "${assignment}"; expected "role=preset"`);
+        }
+        if (agentOverrides.has(role)) {
+            throw new Error(`Agent role "${role}" was overridden more than once`);
+        }
+        agentOverrides.set(role, preset);
+        index += 2;
+    }
+    return {
+        agentOverrides,
+        input: args.slice(index).join(" "),
+    };
+}
+function printMachineListing(found, separate) {
+    if (!process.stdout.isTTY) {
+        if (found.error !== undefined)
+            console.error(found.error);
+        const readiness = found.error !== undefined ? "invalid" : found.missingAgents.length === 0
+            ? "ready"
+            : `missing Agents: ${found.missingAgents.join(", ")}`;
+        console.log(`${found.name}\t${found.description}\t${found.path}\t${readiness}`);
+        return;
+    }
+    if (separate)
+        console.log();
+    console.log(bold(cyan(found.name)));
+    console.log(`  ${found.description}`);
+    console.log(`  ${dim(found.path)}`);
+    if (found.error !== undefined)
+        console.log(`  ${red(found.error)}`);
+    if (found.missingAgents.length > 0) {
+        console.log(`  ${yellow(`missing Agents: ${found.missingAgents.join(", ")}`)}`);
+    }
+}
+function printAgentListing(preset, separate) {
+    const identity = [preset.harness, preset.model, preset.thinking].filter(Boolean);
+    if (!process.stdout.isTTY) {
+        console.log([
+            preset.name,
+            preset.description,
+            preset.harness ?? "",
+            preset.model ?? "",
+            preset.thinking ?? "",
+            preset.source,
+        ].join("\t"));
+        return;
+    }
+    if (separate)
+        console.log();
+    console.log(bold(cyan(preset.name)));
+    console.log(`  ${preset.description}`);
+    if (identity.length > 0)
+        console.log(`  ${magenta(identity.join(" · "))}`);
+    console.log(`  ${dim(preset.source)}`);
+}
+function printMachineHeader(machinePath) {
+    if (!process.stdout.isTTY) {
+        console.log(`Machine: ${machinePath}`);
+        return;
+    }
+    console.log(`${magenta("◆")} ${bold(machineName(machinePath))}`);
+    console.log(`  ${dim(machinePath)}\n`);
+}
+function createRunStatus(machinePath) {
+    const name = machineName(machinePath);
+    if (!process.stderr.isTTY) {
+        return {
+            onState(state) {
+                console.error(`● ${name} · ${formatState(state)}`);
+            },
+            onAgentUpdate() { },
+            onHumanInput() { },
+            succeed() { },
+            fail() { },
+            close() { },
+        };
+    }
+    let currentState = "starting";
+    let enteredAt = 0;
+    let humanInputActive = false;
+    let activityExpanded = false;
+    let agentOutput = "";
+    let agentIdentity = {};
+    let refresh;
+    const tools = new Map();
+    const hotkeysAvailable = Boolean(process.stdin.isTTY && process.stdin.setRawMode);
+    const initialRawMode = process.stdin.isRaw;
+    let hotkeysEnabled = false;
+    const signalHandlers = new Map();
+    const spinner = yoctoSpinner({ handleSignals: false, stream: process.stderr });
+    function runningText() {
+        const hint = hotkeysAvailable
+            ? ` · ${dim(activityExpanded ? "[o] hide activity" : "[o] activity")}`
+            : "";
+        const status = `${cyan(displayState(currentState))} · ${dim(formatElapsed(Date.now() - enteredAt))}${hint}`;
+        const identity = [
+            agentIdentity.harness,
+            agentIdentity.model,
+            agentIdentity.thinking === undefined
+                ? undefined
+                : `thinking ${agentIdentity.thinking}`,
+        ].filter(Boolean).join(" · ");
+        const identityLine = identity === ""
+            ? ""
+            : `\n  ${dim(truncate(identity, Math.max(20, (process.stderr.columns ?? 100) - 4)))}`;
+        return activityExpanded
+            ? `${status}${identityLine}\n${activityText()}`
+            : `${status}${identityLine}`;
+    }
+    function completedText() {
+        return `${green(displayState(currentState))} · ${dim(formatElapsed(Date.now() - enteredAt))}`;
+    }
+    function clearRefresh() {
+        if (refresh !== undefined)
+            clearInterval(refresh);
+        refresh = undefined;
+    }
+    function completeCurrent() {
+        clearRefresh();
+        if (spinner.isSpinning)
+            spinner.success(completedText());
+    }
+    function activityText() {
+        const toolLines = [...tools.values()].map((tool) => {
+            if (tool.status === "completed")
+                return `${green("✓")} ${tool.title}`;
+            if (tool.status === "failed")
+                return `${red("✖")} ${tool.title}`;
+            if (tool.status === "in_progress")
+                return `${cyan("…")} ${tool.title}`;
+            return `${dim("·")} ${tool.title}`;
+        });
+        const lastNewline = agentOutput.lastIndexOf("\n");
+        const completeOutput = lastNewline === -1 ? "" : agentOutput.slice(0, lastNewline);
+        const outputLines = completeOutput
+            .replace(/^MACHINES_EVENT .+$(?:\r?\n)?/gmu, "")
+            .replace(/^New version available:.+$(?:\r?\n)?/gmu, "")
+            .trim()
+            .split(/\r?\n/u)
+            .filter((line) => line !== "")
+            .slice(-4)
+            .map((line) => `${dim("│")} ${line}`);
+        const lines = [...toolLines, ...outputLines].slice(-8);
+        if (lines.length === 0)
+            return dim("  Waiting for Agent activity…");
+        const width = Math.max(20, (process.stderr.columns ?? 100) - 4);
+        return lines
+            .map((line) => `  ${truncate(stripVTControlCharacters(line), width)}`)
+            .join("\n");
+    }
+    function render() {
+        if (spinner.isSpinning)
+            spinner.text = runningText();
+    }
+    function onKeypress(_character, key) {
+        if (key?.ctrl && key.name === "c") {
+            disableHotkeys();
+            process.kill(process.pid, "SIGINT");
+            return;
+        }
+        if (key?.name !== "o")
+            return;
+        activityExpanded = !activityExpanded;
+        render();
+    }
+    function enableHotkeys() {
+        if (!hotkeysAvailable || hotkeysEnabled)
+            return;
+        emitKeypressEvents(process.stdin);
+        process.stdin.on("keypress", onKeypress);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        hotkeysEnabled = true;
+    }
+    function disableHotkeys() {
+        if (!hotkeysEnabled)
+            return;
+        process.stdin.off("keypress", onKeypress);
+        process.stdin.setRawMode(initialRawMode ?? false);
+        if (!initialRawMode)
+            process.stdin.pause();
+        hotkeysEnabled = false;
+    }
+    function closeHotkeys() {
+        disableHotkeys();
+        for (const [signal, handler] of signalHandlers)
+            process.off(signal, handler);
+        signalHandlers.clear();
+    }
+    if (hotkeysAvailable) {
+        for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+            const handler = () => {
+                closeHotkeys();
+                process.kill(process.pid, signal);
+            };
+            signalHandlers.set(signal, handler);
+            process.once(signal, handler);
+        }
+    }
+    enableHotkeys();
+    return {
+        onAgentUpdate(update) {
+            if (update.type === "identity") {
+                agentIdentity = update;
+            }
+            else if (update.type === "output") {
+                agentOutput = (agentOutput + update.text).slice(-32_768);
+            }
+            else {
+                const previous = tools.get(update.id);
+                tools.set(update.id, {
+                    title: update.title ?? previous?.title ?? "tool",
+                    status: update.status ?? previous?.status,
+                });
+            }
+            render();
+        },
+        onHumanInput(active) {
+            humanInputActive = active;
+            if (active) {
+                disableHotkeys();
+                completeCurrent();
+                process.stderr.write(`${yellow("◆")} ${yellow("input needed")}\n`);
+            }
+            else {
+                enableHotkeys();
+            }
+        },
+        onState(state) {
+            if (!humanInputActive)
+                completeCurrent();
+            currentState = formatState(state);
+            enteredAt = Date.now();
+            agentOutput = "";
+            agentIdentity = {};
+            tools.clear();
+            if (humanInputActive)
+                return;
+            spinner.start(runningText());
+            refresh = setInterval(() => {
+                spinner.text = runningText();
+            }, 1_000);
+            refresh.unref();
+        },
+        succeed() {
+            completeCurrent();
+        },
+        fail() {
+            clearRefresh();
+            const failed = `${red(displayState(currentState))} · ${dim(formatElapsed(Date.now() - enteredAt))}`;
+            if (spinner.isSpinning)
+                spinner.error(failed);
+            else
+                process.stderr.write(`${red("✖")} ${failed}\n`);
+        },
+        close() {
+            closeHotkeys();
+        },
+    };
+}
+function formatState(state) {
+    return typeof state === "string" ? state : JSON.stringify(state);
+}
+function displayState(state) {
+    return state.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").toLowerCase();
+}
+function truncate(text, width) {
+    return text.length <= width ? text : `${text.slice(0, width - 1)}…`;
+}
+function machineName(machinePath) {
+    const file = basename(machinePath);
+    if (file === "index.ts")
+        return basename(dirname(machinePath));
+    return file.endsWith(".ts") ? file.slice(0, -3) : file;
+}
+function formatElapsed(milliseconds) {
+    const seconds = Math.round(milliseconds / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+}

package/dist/src/discovery-worker.d.ts

@@ -0,0 +1,3 @@
+import { type AgentPresetSummary, type LauncherLocation, type MachineSummary } from "./catalog.ts";
+export declare function queryCatalog(kind: "machines", location: LauncherLocation): Promise<readonly MachineSummary[]>;
+export declare function queryCatalog(kind: "agents", location: LauncherLocation): Promise<readonly AgentPresetSummary[]>;

package/dist/src/discovery-worker.js

@@ -0,0 +1,52 @@
+import { machinesUserHome } from "./discovery.js";
+import { resolve } from "node:path";
+import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads";
+import { inspectAgentPresets, inspectMachines, } from "./catalog.js";
+export function queryCatalog(kind, location) {
+    // A fresh module graph also refreshes transitive imports and releases their cache afterward.
+    // This isolates discovery output/lifetime; the imported code remains trusted local code.
+    const job = {
+        machinesCatalog: true,
+        kind,
+        location: {
+            cwd: resolve(location.cwd ?? process.cwd()),
+            home: resolve(location.home ?? machinesUserHome()),
+        },
+    };
+    const worker = new Worker(new URL(import.meta.url), {
+        workerData: job,
+        execArgv: [],
+        stdout: true,
+        stderr: true,
+    });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    return new Promise((resolveReply, reject) => {
+        let settled = false;
+        const finish = (reply) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            void worker.terminate();
+            if ("error" in reply)
+                reject(new Error(reply.error));
+            else
+                resolveReply(reply.entries);
+        };
+        const timer = setTimeout(() => finish({ error: "Machine discovery timed out after 10 seconds" }), 10_000);
+        worker.once("message", (reply) => finish(reply));
+        worker.once("error", (error) => finish({ error: error.message }));
+        worker.once("exit", (code) => finish({ error: `Machine discovery exited before returning results (code ${code})` }));
+    });
+}
+if (!isMainThread && parentPort !== null && workerData?.machinesCatalog === true) {
+    const job = workerData;
+    const port = parentPort;
+    const result = job.kind === "machines"
+        ? inspectMachines(job.location)
+        : inspectAgentPresets(job.location);
+    void result.then((entries) => port.postMessage({ entries }), (cause) => port.postMessage({
+        error: cause instanceof Error ? cause.message : String(cause),
+    }));
+}

package/dist/src/discovery.d.ts

@@ -0,0 +1,8 @@
+/** Select a separate global catalog without changing the process's real home. */
+export declare function machinesUserHome(): string;
+export interface DiscoveredMachine {
+    readonly name: string;
+    readonly path: string;
+}
+export declare function discoverMachines(cwd: string, home: string): Promise<readonly DiscoveredMachine[]>;
+export declare function nearestMachinesDirectory(cwd: string): Promise<string | undefined>;