@rynx-ai/cli 0.1.10

package/dist/commands/browser.js

@@ -0,0 +1,273 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { connectBrowserAutomation, } from "@rynx-ai/browser-cdp";
+import WebSocket from "ws";
+import { parseBrowserCliArgs, resolveBrowserCliTarget, } from "../browser-cli-args.js";
+import { callManagedRuntimeBrowser, callResidentRuntime, cleanResidentBrowserArtifacts, getResidentBrowserArtifactVersion, getResidentRuntimeLocalBrowserAutomationAccess, getResidentRuntimeLocalBrowserEndpoint, installResidentBrowserArtifact, readOptionalManagedRuntimeBrowserCredential, updateResidentBrowserArtifact, } from "../control-client.js";
+import { fail } from "./errors.js";
+export async function runBrowserCommand(args) {
+    let parsed;
+    try {
+        parsed = parseBrowserCliArgs(args);
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+    if (parsed.subcommand === "install" || parsed.subcommand === "update") {
+        if (parsed.version && parsed.channel) {
+            fail("browser install: choose either --version or --channel");
+        }
+        const channel = browserReleaseChannel(parsed.channel);
+        const result = parsed.subcommand === "install"
+            ? await installResidentBrowserArtifact(parsed.version ? { version: parsed.version } : { channel })
+            : await updateResidentBrowserArtifact({ channel });
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                resolved: result.resolved,
+                installed: result.installed,
+            }, null, 2));
+        }
+        else {
+            for (const message of result.messages)
+                console.log(message);
+            console.log(`Active Browser engine: Chrome for Testing ${result.installed.version}.`);
+        }
+        return 0;
+    }
+    if (parsed.subcommand === "version") {
+        const { installed } = await getResidentBrowserArtifactVersion();
+        if (parsed.json)
+            console.log(JSON.stringify({ installed }, null, 2));
+        else if (installed) {
+            console.log(`Chrome for Testing ${installed.version} · ${installed.hostPlatform} · ${installed.sha256}`);
+        }
+        else {
+            console.log("No managed Chrome for Testing build is installed.");
+        }
+        return 0;
+    }
+    if (parsed.subcommand === "clean") {
+        const result = await cleanResidentBrowserArtifacts();
+        if (parsed.json)
+            console.log(JSON.stringify(result, null, 2));
+        else if (result.removedBuilds.length === 0) {
+            console.log("No inactive Chrome for Testing builds were eligible for removal.");
+        }
+        else {
+            console.log(`Removed ${result.removedBuilds.length} inactive Chrome for Testing build(s).`);
+        }
+        return 0;
+    }
+    const json = parsed.json;
+    if (parsed.subcommand === "endpoint") {
+        const target = await resolveBrowserTarget(parsed);
+        if (parsed.ensure) {
+            await callBrowserRuntime(target, "browser.open", { sessionId: target.sessionId });
+        }
+        const descriptor = await getResidentRuntimeLocalBrowserEndpoint({
+            ...(target.credential ? {} : { sessionId: target.sessionId }),
+        });
+        console.log(json ? JSON.stringify(descriptor, null, 2) : descriptor.endpoint);
+        return 0;
+    }
+    const target = await resolveBrowserTarget(parsed);
+    if (isAutomationCommand(parsed.subcommand)) {
+        return runBrowserAutomation(parsed, target);
+    }
+    const sessionId = target.sessionId;
+    if (parsed.subcommand === "open") {
+        const state = await callBrowserRuntime(target, "browser.open", {
+            sessionId,
+            ...(parsed.url ? { url: parsed.url } : {}),
+        });
+        printBrowserState(state, json);
+        return 0;
+    }
+    const state = await callBrowserRuntime(target, "browser.state.get", { sessionId });
+    if (parsed.subcommand === "status") {
+        printBrowserState(state, json);
+        return 0;
+    }
+    if (parsed.subcommand === "pages") {
+        if (json)
+            console.log(JSON.stringify({ pages: state?.pages ?? [] }, null, 2));
+        else
+            printBrowserPages(state);
+        return 0;
+    }
+    if (!state) {
+        if (json)
+            console.log(JSON.stringify({ closed: false, browser: null }, null, 2));
+        else
+            console.log(`No Browser is open for Session ${sessionId}.`);
+        return 0;
+    }
+    const result = await callBrowserRuntime(target, "browser.close", {
+        sessionId,
+        browserGeneration: state.browserGeneration,
+    });
+    console.log(json
+        ? JSON.stringify(result, null, 2)
+        : `Closed Browser generation ${result.browserGeneration} for Session ${sessionId}.`);
+    return 0;
+}
+function browserReleaseChannel(value) {
+    const normalized = value?.toLowerCase() ?? "stable";
+    if (normalized !== "stable" &&
+        normalized !== "beta" &&
+        normalized !== "dev" &&
+        normalized !== "canary") {
+        fail("browser: --channel must be stable, beta, dev, or canary");
+    }
+    return normalized;
+}
+async function runBrowserAutomation(parsed, target) {
+    if (target.runtimeSelector !== "local") {
+        fail(`browser ${parsed.subcommand}: automation is available only on the local Runtime`);
+    }
+    const automationAccess = await getResidentRuntimeLocalBrowserAutomationAccess({
+        ...(target.credential ? {} : { sessionId: target.sessionId }),
+    });
+    const descriptor = automationAccess.descriptor;
+    let client;
+    try {
+        client = await connectBrowserAutomation({
+            endpoint: descriptor.endpoint,
+            ...(descriptor.pageTargetId ? { pageTargetId: descriptor.pageTargetId } : {}),
+            referenceKey: automationAccess.referenceKey,
+            createWebSocket: (endpoint) => new WebSocket(endpoint),
+        });
+        if (parsed.subcommand === "snapshot") {
+            const snapshot = await client.snapshot();
+            if (parsed.json) {
+                console.log(JSON.stringify({
+                    sessionId: descriptor.sessionId,
+                    browserGeneration: descriptor.browserGeneration,
+                    snapshot,
+                }, null, 2));
+            }
+            else {
+                printAutomationSnapshot(snapshot.nodes);
+            }
+            return 0;
+        }
+        if (parsed.subcommand === "navigate") {
+            const navigation = await client.navigate(parsed.url);
+            printAutomationResult(parsed, descriptor.browserGeneration, navigation);
+            return 0;
+        }
+        if (parsed.subcommand === "click") {
+            const clickTarget = parsed.ref !== undefined
+                ? { ref: parsed.ref }
+                : parsed.selector !== undefined
+                    ? { selector: parsed.selector }
+                    : { x: parsed.x, y: parsed.y };
+            await client.click(clickTarget);
+            printAutomationResult(parsed, descriptor.browserGeneration);
+            return 0;
+        }
+        if (parsed.subcommand === "type") {
+            const typeTarget = parsed.ref !== undefined
+                ? { ref: parsed.ref }
+                : { selector: parsed.selector };
+            await client.type(typeTarget, parsed.text);
+            printAutomationResult(parsed, descriptor.browserGeneration);
+            return 0;
+        }
+        const screenshot = await client.screenshot({
+            ...(parsed.format ? { format: parsed.format } : {}),
+            ...(parsed.quality !== undefined ? { quality: parsed.quality } : {}),
+        });
+        const output = path.resolve(parsed.output);
+        if (!path.isAbsolute(parsed.output)) {
+            fail("browser screenshot: --output must be an absolute path");
+        }
+        await writeFile(output, Buffer.from(screenshot.data, "base64"), { mode: 0o600 });
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                completed: true,
+                browserGeneration: descriptor.browserGeneration,
+                output,
+                format: screenshot.format,
+                mimeType: screenshot.mimeType,
+            }, null, 2));
+        }
+        else {
+            console.log(output);
+        }
+        return 0;
+    }
+    finally {
+        client?.close();
+    }
+}
+async function resolveBrowserTarget(args) {
+    const credential = await readOptionalManagedRuntimeBrowserCredential();
+    try {
+        return resolveBrowserCliTarget(args, credential);
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+}
+async function callBrowserRuntime(target, method, params) {
+    if (target.credential) {
+        return callManagedRuntimeBrowser(target.credential, method, params);
+    }
+    return callResidentRuntime(target.runtimeSelector, method, params);
+}
+function printBrowserState(state, json) {
+    if (json) {
+        console.log(JSON.stringify({ browser: state }, null, 2));
+        return;
+    }
+    if (!state) {
+        console.log("No Browser is open for this Session.");
+        return;
+    }
+    console.log(`Browser ${state.status} · ${state.executionBackend} · ` +
+        `generation ${state.browserGeneration}`);
+    printBrowserPages(state);
+}
+function printBrowserPages(state) {
+    if (!state || state.pages.length === 0) {
+        console.log("  (no Pages)");
+        return;
+    }
+    for (const page of state.pages) {
+        const marker = page.pageId === state.activePageId ? "*" : " ";
+        const title = page.title ? `  ${page.title}` : "";
+        console.log(`${marker} ${page.pageId}  ${page.url}${title}`);
+    }
+}
+function isAutomationCommand(subcommand) {
+    return subcommand === "snapshot"
+        || subcommand === "navigate"
+        || subcommand === "click"
+        || subcommand === "type"
+        || subcommand === "screenshot";
+}
+function printAutomationResult(parsed, browserGeneration, result = {}) {
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            completed: true,
+            browserGeneration,
+            ...result,
+        }, null, 2));
+    }
+    else {
+        console.log(`Browser ${parsed.subcommand} completed.`);
+    }
+}
+function printAutomationSnapshot(nodes) {
+    if (nodes.length === 0) {
+        console.log("(empty accessibility tree)");
+        return;
+    }
+    for (const node of nodes) {
+        const name = node.name ? ` ${JSON.stringify(node.name)}` : "";
+        const value = node.value ? ` value=${JSON.stringify(node.value)}` : "";
+        const ref = node.ref ? ` ref=${node.ref}` : "";
+        console.log(`${node.role}${name}${value}${ref}`);
+    }
+}

package/dist/commands/cleanup.d.ts

@@ -0,0 +1 @@
+export declare function runCleanupCommand(args: readonly string[]): Promise<number>;

package/dist/commands/cleanup.js

@@ -0,0 +1,24 @@
+import { cleanupResidentSessions } from "../control-client.js";
+import { fail } from "./errors.js";
+export async function runCleanupCommand(args) {
+    if (args[0] !== "sessions") {
+        fail("cleanup: only `cleanup sessions` is supported");
+    }
+    let dryRun = false;
+    for (const arg of args.slice(1)) {
+        if (arg !== "--dry-run") {
+            fail(`cleanup sessions: unknown option ${arg}`);
+        }
+        if (dryRun)
+            fail("cleanup sessions: duplicate option --dry-run");
+        dryRun = true;
+    }
+    const result = await cleanupResidentSessions({ dryRun });
+    const summary = `${result.deletedSessions} session(s), ` +
+        `${result.deletedLogRows} log row(s), ` +
+        `${result.prunedStoreEntries} store entr(ies)`;
+    console.log(result.dryRun
+        ? `Dry run: would delete ${summary}.`
+        : `Deleted ${summary}.`);
+    return 0;
+}

package/dist/commands/emulator.d.ts

@@ -0,0 +1 @@
+export declare function runEmulatorCommand(args: readonly string[]): Promise<number>;

package/dist/commands/emulator.js

@@ -0,0 +1,23 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+export async function runEmulatorCommand(args) {
+    const require = createRequire(import.meta.url);
+    const cliPath = path.join(path.dirname(require.resolve("@rynx-ai/emulator")), "cli.js");
+    return runNodeCli(cliPath, args);
+}
+function runNodeCli(cliPath, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [cliPath, ...args], { stdio: "inherit" });
+        child.once("error", (error) => {
+            reject(new Error(`rynx emulator: failed to launch the bundled CLI: ${error.message}`));
+        });
+        child.once("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`rynx emulator: bundled CLI exited with signal ${signal}`));
+                return;
+            }
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/commands/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class CliUsageError extends Error {
+    readonly exitCode = 2;
+    constructor(message: string);
+}
+export declare function fail(message: string): never;

package/dist/commands/errors.js

@@ -0,0 +1,10 @@
+export class CliUsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+    }
+}
+export function fail(message) {
+    throw new CliUsageError(message);
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+export { runAgentCommand } from "./agent.js";
+export { runAppDistributionCommand, shouldUseAppDistributionCommand, } from "./app-distribution.js";
+export { runBrowserCommand } from "./browser.js";
+export { runCleanupCommand } from "./cleanup.js";
+export { runEmulatorCommand } from "./emulator.js";
+export { CliUsageError } from "./errors.js";
+export { type PluginManageCommandOptions, runPluginCommand, runPluginManageCommand, } from "./plugin.js";
+export { runRuntimeCommand } from "./runtime.js";
+export { builtinSkillsDirectory, listBuiltinSkills, readBuiltinSkill, runSkillsCommand, } from "./skills.js";

package/dist/commands/index.js

@@ -0,0 +1,9 @@
+export { runAgentCommand } from "./agent.js";
+export { runAppDistributionCommand, shouldUseAppDistributionCommand, } from "./app-distribution.js";
+export { runBrowserCommand } from "./browser.js";
+export { runCleanupCommand } from "./cleanup.js";
+export { runEmulatorCommand } from "./emulator.js";
+export { CliUsageError } from "./errors.js";
+export { runPluginCommand, runPluginManageCommand, } from "./plugin.js";
+export { runRuntimeCommand } from "./runtime.js";
+export { builtinSkillsDirectory, listBuiltinSkills, readBuiltinSkill, runSkillsCommand, } from "./skills.js";

package/dist/commands/plugin.d.ts

@@ -0,0 +1,6 @@
+export interface PluginManageCommandOptions {
+    interactive?: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+}
+export declare function runPluginManageCommand(args: readonly string[], options?: PluginManageCommandOptions): Promise<number>;
+export declare function runPluginCommand(args: readonly string[]): Promise<number>;

package/dist/commands/plugin.js

@@ -0,0 +1,289 @@
+import { createInterface } from "node:readline/promises";
+import { cancelResidentPluginInstallation, commitResidentPluginInstallation, invokeResidentPluginCommand, listResidentPlugins, prepareResidentPluginInstallation, reloadResidentPluginRuntime, setResidentPluginEnabled, uninstallResidentPlugin, } from "../control-client.js";
+import { fail } from "./errors.js";
+const PLUGIN_STDIN_MAX_BYTES = 256 * 1024;
+const PLUGIN_DIGEST_PATTERN = /^sha256-[A-Za-z0-9+/]{43}={0,2}$/;
+export async function runPluginManageCommand(args, options = {}) {
+    const [subcommand, pluginId] = args;
+    switch (subcommand) {
+        case "list": {
+            const plugins = await listResidentPlugins();
+            console.log("Plugins");
+            if (plugins.length === 0) {
+                console.log("  (none)");
+                return 0;
+            }
+            for (const plugin of plugins) {
+                console.log(`  ${plugin.id.padEnd(16)} ${(plugin.version ?? "-").padEnd(10)} ` +
+                    `${plugin.source.padEnd(6)} ${plugin.state}`);
+            }
+            return 0;
+        }
+        case "enable":
+        case "disable": {
+            if (!pluginId)
+                fail(`plugin manage ${subcommand}: missing plugin id`);
+            await setResidentPluginEnabled(pluginId, subcommand === "enable");
+            console.log(`Plugin "${pluginId}" ${subcommand}d. Run \`rynx restart\` to apply.`);
+            return 0;
+        }
+        case "uninstall": {
+            if (!pluginId)
+                fail("plugin manage uninstall: missing plugin id");
+            await uninstallResidentPlugin(pluginId);
+            console.log(`Plugin "${pluginId}" uninstalled. Run \`rynx restart\` to apply.`);
+            return 0;
+        }
+        case "install":
+        case "update": {
+            const parsed = parseInstallationArgs(subcommand, args.slice(1));
+            const preparation = await prepareResidentPluginInstallation({
+                operation: subcommand,
+                ...(subcommand === "install"
+                    ? { spec: parsed.target }
+                    : { pluginId: parsed.target }),
+                allowScripts: parsed.allowScripts,
+            });
+            let committed = false;
+            try {
+                if (!parsed.json)
+                    printPreparation(preparation);
+                const interactive = options.interactive ??
+                    Boolean(process.stdin.isTTY && process.stdout.isTTY);
+                const confirm = options.confirm ?? confirmInTerminal;
+                if (parsed.expectedDigest !== undefined &&
+                    parsed.expectedDigest !== preparation.artifact.digest) {
+                    fail(`prepared plugin digest ${preparation.artifact.digest} does not match ` +
+                        `--expect-digest ${parsed.expectedDigest}`);
+                }
+                if ((!interactive || parsed.json) &&
+                    (parsed.force || parsed.grantAll || parsed.allowScripts) &&
+                    parsed.expectedDigest === undefined) {
+                    fail("non-interactive --force/--grant-all/--allow-scripts approval must be bound to the " +
+                        `prepared artifact; re-run with --expect-digest ${preparation.artifact.digest}`);
+                }
+                if (preparation.artifact.requiresBuildScripts && !parsed.allowScripts) {
+                    fail(`plugin "${preparation.artifact.id}" requires package build scripts; ` +
+                        `review digest ${preparation.artifact.digest} and re-run with ` +
+                        `--allow-scripts --expect-digest ${preparation.artifact.digest}`);
+                }
+                if (preparation.artifact.requiresBuildScripts &&
+                    parsed.allowScripts &&
+                    parsed.expectedDigest === undefined) {
+                    const approved = await confirm(`Run declared build scripts from digest ${preparation.artifact.digest}?`);
+                    if (!approved) {
+                        console.log("Plugin installation cancelled; build scripts were not run.");
+                        return 0;
+                    }
+                }
+                let overwrite = subcommand === "update";
+                if (subcommand === "install" && preparation.existing) {
+                    overwrite = parsed.force;
+                    if (!overwrite) {
+                        if (!interactive || parsed.json) {
+                            fail(`plugin "${preparation.artifact.id}" already exists; ` +
+                                `inspect digest ${preparation.artifact.digest} and re-run with ` +
+                                `--force --expect-digest ${preparation.artifact.digest}`);
+                        }
+                        overwrite = await confirm(`Overwrite installed plugin "${preparation.artifact.id}" with this artifact?`);
+                        if (!overwrite) {
+                            console.log("Plugin installation cancelled; the existing plugin was not changed.");
+                            return 0;
+                        }
+                    }
+                }
+                let grants = [...preparation.capabilityDiff.retained];
+                if (preparation.capabilityDiff.added.length > 0) {
+                    if (parsed.grantAll) {
+                        grants = [...preparation.artifact.requestedCapabilities];
+                    }
+                    else {
+                        if (!interactive || parsed.json) {
+                            fail(`plugin "${preparation.artifact.id}" requests new capabilities ` +
+                                `(${preparation.capabilityDiff.added.join(", ")}); inspect digest ` +
+                                `${preparation.artifact.digest} and re-run with ` +
+                                `--grant-all --expect-digest ${preparation.artifact.digest}`);
+                        }
+                        const approved = await confirm(`Grant ${preparation.capabilityDiff.added.length} new capability(s) ` +
+                            `to "${preparation.artifact.id}"?`);
+                        if (!approved) {
+                            console.log("Plugin installation cancelled; no changes were made.");
+                            return 0;
+                        }
+                        grants = [...preparation.artifact.requestedCapabilities];
+                    }
+                }
+                const result = await commitResidentPluginInstallation(preparation.token, {
+                    grants,
+                    overwrite,
+                    expectedDigest: preparation.artifact.digest,
+                });
+                committed = true;
+                let runtimeReloaded = false;
+                if (parsed.restart) {
+                    try {
+                        await reloadResidentPluginRuntime(result.plugin.id);
+                        runtimeReloaded = true;
+                    }
+                    catch (error) {
+                        throw new Error(`Plugin "${result.plugin.id}" was committed, but its runtime did not reload: ` +
+                            `${messageOf(error)}`, { cause: error });
+                    }
+                }
+                if (parsed.json) {
+                    console.log(JSON.stringify({
+                        preparation: publicPreparation(preparation),
+                        plugin: result.plugin,
+                        runtimeReloaded,
+                    }, null, 2));
+                }
+                else {
+                    const action = subcommand === "install" ? "installed" : "updated";
+                    console.log(`Plugin "${result.plugin.id}"${result.plugin.version
+                        ? ` @${result.plugin.version}`
+                        : ""} ${action}.`);
+                    console.log(parsed.restart
+                        ? `Plugin "${result.plugin.id}" runtime is ready.`
+                        : "Use --restart to reload the plugin runtime now.");
+                }
+                return 0;
+            }
+            finally {
+                if (!committed) {
+                    await cancelResidentPluginInstallation(preparation.token).catch(() => false);
+                }
+            }
+        }
+        default:
+            fail("plugin manage: expected list, install, update, uninstall, enable, or disable");
+    }
+}
+export async function runPluginCommand(args) {
+    const [pluginId, command] = args;
+    if (!pluginId)
+        fail("plugin: missing plugin id");
+    if (pluginId === "manage") {
+        return runPluginManageCommand(args.slice(1));
+    }
+    if (!command)
+        fail(`plugin ${pluginId}: missing command`);
+    const stdin = process.stdin.isTTY
+        ? undefined
+        : await readStdinBounded(PLUGIN_STDIN_MAX_BYTES);
+    const result = await invokeResidentPluginCommand(pluginId, args.slice(1), stdin === undefined ? {} : { stdin });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    if (result.truncated) {
+        process.stderr.write("rynx: plugin command output was truncated by the daemon\n");
+    }
+    return result.code;
+}
+function parseInstallationArgs(operation, args) {
+    const target = args[0];
+    if (!target || target.startsWith("--")) {
+        fail(operation === "install"
+            ? "plugin manage install: missing npm/path/git/url source"
+            : "plugin manage update: missing plugin id");
+    }
+    const flags = new Set();
+    const allowedFlags = new Set([
+        "--force",
+        "--grant-all",
+        "--allow-scripts",
+        "--restart",
+        "--json",
+    ]);
+    let expectedDigest;
+    for (let index = 1; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--expect-digest" || arg === "--expected-digest") {
+            if (expectedDigest !== undefined) {
+                fail(`plugin manage ${operation}: duplicate digest expectation`);
+            }
+            const value = args[index + 1];
+            if (!value || value.startsWith("--")) {
+                fail(`plugin manage ${operation}: ${arg} requires a value`);
+            }
+            if (!PLUGIN_DIGEST_PATTERN.test(value)) {
+                fail(`plugin manage ${operation}: ${arg} must be a sha256 digest`);
+            }
+            expectedDigest = value;
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            fail(`plugin manage ${operation}: unexpected argument ${arg}`);
+        }
+        if (!allowedFlags.has(arg)) {
+            fail(`plugin manage ${operation}: unknown option ${arg}`);
+        }
+        if (flags.has(arg)) {
+            fail(`plugin manage ${operation}: duplicate option ${arg}`);
+        }
+        flags.add(arg);
+    }
+    return {
+        target,
+        force: flags.has("--force"),
+        grantAll: flags.has("--grant-all"),
+        allowScripts: flags.has("--allow-scripts"),
+        restart: flags.has("--restart"),
+        json: flags.has("--json"),
+        ...(expectedDigest ? { expectedDigest } : {}),
+    };
+}
+function printPreparation(preparation) {
+    const version = preparation.artifact.version
+        ? ` @${preparation.artifact.version}`
+        : "";
+    console.log(`Prepared plugin "${preparation.artifact.id}"${version}.`);
+    console.log(`Artifact digest: ${preparation.artifact.digest}`);
+    if (preparation.artifact.requiresBuildScripts) {
+        console.log("Package build scripts: required and explicitly enabled.");
+    }
+    printCapabilities("New capabilities", preparation.capabilityDiff.added);
+    printCapabilities("Retained capabilities", preparation.capabilityDiff.retained);
+    printCapabilities("Removed capabilities", preparation.capabilityDiff.removed);
+}
+function printCapabilities(label, capabilities) {
+    if (capabilities.length === 0)
+        return;
+    console.log(`${label}:`);
+    for (const capability of capabilities)
+        console.log(`  - ${capability}`);
+}
+function publicPreparation(preparation) {
+    const { token: _token, ...publicFields } = preparation;
+    return publicFields;
+}
+async function confirmInTerminal(message) {
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await prompt.question(`${message} [y/N] `);
+        return answer.trim().toLowerCase() === "y" ||
+            answer.trim().toLowerCase() === "yes";
+    }
+    finally {
+        prompt.close();
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function readStdinBounded(maxBytes) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += value.byteLength;
+        if (bytes > maxBytes)
+            fail(`plugin stdin exceeds ${maxBytes} bytes`);
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks, bytes).toString("utf8");
+}

package/dist/commands/runtime.d.ts

@@ -0,0 +1 @@
+export declare function runRuntimeCommand(args: readonly string[]): Promise<number>;