@widgetic/cli 0.0.0-stage → 0.1.2

package/dist/help.js

@@ -0,0 +1,174 @@
+import { editDistance } from "./commands/schema.js";
+import { loadMcpManifest, loadRestManifest } from "./manifest/load.js";
+import { API_GROUP_SUMMARIES } from "./overlay.js";
+/**
+ * What the screens a new person meets first say beyond what the contracts say: the headings that sort the commands of
+ * `widgetic --help`, the "Get started" and "Examples" at the foot of `widgetic`, `widgetic api` and `widgetic mcp`, the
+ * line each group of the REST API gets, and what is said after a word that is no command.
+ *
+ * The commands themselves, their flags and their descriptions come from the contracts and are not here. Every command
+ * an example names is checked by `test/help.test.ts` (it exists, and so does every flag), so the help cannot send
+ * a person to a command that was renamed. The lines are short on purpose (78 characters at most): the text of a
+ * footer is printed as it is written, and a terminal that is 80 columns wide would break a longer one.
+ */
+/** The headings that sort the commands of `widgetic --help`: what you do with Widgetic, how you set it up, how you look things up. */
+export const ROOT_HEADINGS = {
+    work: 'Work with Widgetic:',
+    setup: 'Set up:',
+    lookup: 'Look things up:'
+};
+/** The dashboard, where an API key is made (Settings > API Keys): the address the documentation gives for it. */
+const DASHBOARD = 'app.widgetic.com';
+/** The first steps of a person who has just installed the CLI: the first is made in the dashboard, the rest are commands. */
+export const GET_STARTED_COMMANDS = [
+    { command: 'widgetic auth login', says: 'save it (it is asked for, and never shown)' },
+    { command: 'widgetic doctor', says: 'check that the key and both servers work' },
+    { command: 'widgetic mcp list-widgets', says: 'see your widgets' }
+];
+/** Commands that are safe to run to see what the CLI does: they read, or they only print the request. */
+export const ROOT_EXAMPLES = [
+    'widgetic mcp list-widgets',
+    'widgetic api widgets list --json',
+    'widgetic mcp create-widget --title Launch --brief "A countdown" --dry-run',
+    'widgetic schema mcp create-widget'
+];
+export const API_EXAMPLES = [
+    'widgetic api widgets list',
+    'widgetic api compositions list --size 5',
+    'widgetic api tokens validate-token'
+];
+export const MCP_EXAMPLES = [
+    'widgetic mcp list-widgets',
+    'widgetic mcp create-widget --title Launch --brief "A countdown" --wait',
+    'widgetic mcp create-widget --help'
+];
+/** A block of lines indented by two spaces, under a heading. */
+function section(heading, lines) {
+    return `${heading}\n${lines.map((line) => `  ${line}`).join('\n')}`;
+}
+/** The numbered steps of "Get started", with the sentence of each command aligned in a column. */
+function stepLines() {
+    const width = Math.max(...GET_STARTED_COMMANDS.map((step) => step.command.length));
+    return [
+        `1. Make an API key in the dashboard (Settings > API Keys, ${DASHBOARD}).`,
+        ...GET_STARTED_COMMANDS.map((step, index) => `${index + 2}. ${step.command.padEnd(width)}  ${step.says}`)
+    ];
+}
+/** What `widgetic --help` ends with. */
+export function rootHelpFooter() {
+    return [
+        '',
+        section('Get started:', stepLines()),
+        '',
+        section('Examples:', ROOT_EXAMPLES),
+        '',
+        'Add --json to get the result as one line of JSON, for scripts. Add --dry-run',
+        'to a command that calls the API to print the request and send nothing.',
+        'Add --help to any command to see what it takes.'
+    ].join('\n');
+}
+/** What `widgetic api --help` ends with. */
+export function apiHelpFooter() {
+    return [
+        '',
+        section('Examples:', API_EXAMPLES),
+        '',
+        'Run widgetic api <group> --help to list the commands of a group. A group',
+        'that needs a partner API key says so.'
+    ].join('\n');
+}
+/** What `widgetic mcp --help` ends with. */
+export function mcpHelpFooter() {
+    return [
+        '',
+        section('Examples:', MCP_EXAMPLES),
+        '',
+        'A command that builds a widget starts the build and answers at once; --wait',
+        'keeps asking until the build is finished and prints the finished widget.'
+    ].join('\n');
+}
+/** Every command of a group needs a partner API key (`wgt_prt_…`), so the group's line says so. */
+function needsPartnerKey(group) {
+    const listed = group.commands.filter((command) => !command.hidden);
+    return listed.length > 0 && listed.every((command) => command.accessLevel === 'partner');
+}
+/**
+ * The line a group of the REST API gets in the list of `widgetic api --help` and at the top of its own help: what it
+ * works on, from the overlay, and the kind of key it needs when that is always the partner's. A group the overlay does
+ * not know (a later contract added it) is listed by its name and its number of commands, which is true if not pretty.
+ */
+export function apiGroupSummary(group) {
+    const count = group.commands.length;
+    const written = API_GROUP_SUMMARIES[group.name] ?? `${group.title}: ${count} ${count === 1 ? 'command' : 'commands'}.`;
+    return needsPartnerKey(group) ? `${written.replace(/\.$/, '')} (needs a partner key).` : written;
+}
+/** A name without its separators or its case, so `list_widgets`, `list-widgets` and `ListWidgets` are one word. */
+const alphanumeric = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, '');
+/**
+ * The commands of `argv` that exist, from the program down: `api widgets` for `api widgets get`, where `get` is not a
+ * command of `widgets`. A word that is not a command (a flag's value, the unknown word itself) ends the walk, so what
+ * is returned is always a command the person can ask for `--help`.
+ */
+export function existingCommandPath(root, argv) {
+    let command = root;
+    const path = [];
+    for (const word of argv) {
+        if (word.startsWith('-'))
+            continue;
+        const next = command.commands.find((child) => child.name() === word || child.aliases().includes(word));
+        if (!next)
+            break;
+        command = next;
+        path.push(next.name());
+    }
+    return path;
+}
+/** The word of a command line that is the name of the command: the first one that is not a flag. */
+export function firstCommandWord(argv) {
+    return argv.find((word) => !word.startsWith('-'));
+}
+/**
+ * What to say after `widgetic <word>` when the word is no command of `widgetic`. People coming from other tools leave
+ * out the namespace (`widgetic widgets list`, `widgetic list-widgets`), so the word is looked for among the groups of
+ * the REST API and the tools of the MCP server, and a name that is close to one is offered. One line: the hint is
+ * printed on a single indented line.
+ */
+export function unknownCommandHint(word, rest = []) {
+    const fallback = 'Run widgetic --help to see the commands.';
+    try {
+        const groups = loadRestManifest().groups.filter((group) => !group.hidden);
+        const tools = loadMcpManifest().commands;
+        const typed = alphanumeric(word);
+        const group = groups.find((candidate) => alphanumeric(candidate.name) === typed);
+        if (group) {
+            // The words the person typed after the group, up to the first flag (`widgets list --id x` is `list`).
+            const following = [];
+            for (const next of rest) {
+                if (next.startsWith('-'))
+                    break;
+                following.push(next);
+            }
+            return `"${word}" is in the REST API: try widgetic api ${[group.name, ...following].join(' ')}`;
+        }
+        const tool = tools.find((candidate) => alphanumeric(candidate.name) === typed);
+        if (tool)
+            return `"${word}" is a tool of the MCP server: try widgetic mcp ${tool.name}`;
+        // Only names a typo away: a name that merely contains the word (`widget` is in a dozen tools) would bury the one meant.
+        const allowed = typed.length >= 5 ? 2 : 1;
+        const closeTo = (names) => names
+            .map((name) => ({ name, distance: editDistance(typed, alphanumeric(name)) }))
+            .filter((entry) => entry.distance <= allowed)
+            .sort((a, b) => a.distance - b.distance || a.name.localeCompare(b.name))
+            .map((entry) => entry.name);
+        const near = [
+            ...closeTo(groups.map((candidate) => candidate.name)).map((name) => `widgetic api ${name}`),
+            ...closeTo(tools.map((candidate) => candidate.name)).map((name) => `widgetic mcp ${name}`)
+        ].slice(0, 3);
+        if (near.length > 0)
+            return `Did you mean ${near.join(' or ')}? ${fallback}`;
+    }
+    catch {
+        // The manifests could not be read (a broken install): `widgetic doctor` says so; the hint is only a courtesy.
+    }
+    return fallback;
+}

package/dist/http.js

@@ -0,0 +1,122 @@
+import { KEY_REFUSED_HINT } from "./constants.js";
+import { CliError, EXIT_CODES, exitCodeForStatus } from "./errors.js";
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Reads a whole answer. */
+export async function readAnswer(response) {
+    const text = await response.text();
+    const type = response.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase() ?? '';
+    let body;
+    if (text !== '') {
+        if (type.includes('json')) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
+        }
+        else {
+            body = text;
+        }
+    }
+    return { status: response.status, headers: response.headers, body };
+}
+/** `Retry-After` is a number of seconds or a date; either way, seconds from now (never negative). */
+export function parseRetryAfter(value, now) {
+    if (value === null || value.trim() === '')
+        return undefined;
+    if (/^\d+$/.test(value.trim()))
+        return Number(value.trim());
+    const date = Date.parse(value);
+    if (Number.isNaN(date))
+        return undefined;
+    return Math.max(0, Math.ceil((date - now.getTime()) / 1000));
+}
+function upgradeHint(details) {
+    const command = isRecord(details) ? details.upgradeCommand : undefined;
+    // The gateway names the package of the client it recognised; for this CLI that is `@widgetic/cli`.
+    return typeof command === 'string' ? `Update the CLI: ${command}` : undefined;
+}
+/** The error an answer that was not a success stands for. */
+export function errorFromAnswer(answer, now, keySource) {
+    const { status, headers, body } = answer;
+    const envelope = isRecord(body) && isRecord(body.error) ? body.error : undefined;
+    const text = typeof body === 'string' ? body.trim() : '';
+    // The MCP endpoint answers an OAuth-style body to a key it does not accept: `{"error":"invalid_token","error_description":"…"}`.
+    const oauthCode = isRecord(body) && typeof body.error === 'string' ? body.error : undefined;
+    const oauthMessage = isRecord(body) && typeof body.error_description === 'string' ? body.error_description : undefined;
+    const code = typeof envelope?.code === 'string' ? envelope.code : (oauthCode ?? `HTTP_${status}`);
+    const message = (typeof envelope?.message === 'string' && envelope.message) ||
+        (isRecord(body) && typeof body.message === 'string' && body.message) ||
+        oauthMessage ||
+        (text !== '' && text.slice(0, 300)) ||
+        `The server answered ${status}.`;
+    const requestId = (typeof envelope?.correlationId === 'string' && envelope.correlationId) ||
+        headers.get('x-correlation-id') ||
+        undefined;
+    const retryAfter = (typeof envelope?.retryAfter === 'number' ? envelope.retryAfter : undefined) ??
+        parseRetryAfter(headers.get('retry-after'), now);
+    let details = envelope?.details;
+    if (typeof envelope?.param === 'string') {
+        const rest = isRecord(details) ? details : details === undefined ? {} : { detail: details };
+        details = { param: envelope.param, ...rest };
+    }
+    const suggested = typeof envelope?.suggestedAction === 'string' ? envelope.suggestedAction : undefined;
+    let hint = suggested;
+    if (status === 401) {
+        hint =
+            keySource === 'environment'
+                ? 'The key in WIDGETIC_API_KEY was not accepted: check it, or unset it to use the saved one.'
+                : KEY_REFUSED_HINT;
+    }
+    else if (status === 426) {
+        hint = upgradeHint(details) ?? suggested;
+    }
+    else if (status === 429 && retryAfter !== undefined) {
+        hint = `Rate limited: try again in ${retryAfter}s.`;
+    }
+    return new CliError({
+        code,
+        message,
+        exitCode: exitCodeForStatus(status),
+        status,
+        requestId,
+        retryAfter,
+        details,
+        hint
+    });
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+/** What went wrong before there was an answer: a wait that ran out, a host that cannot be reached. */
+export function networkFailure(error, url, timeoutMilliseconds) {
+    const name = error instanceof Error ? error.name : '';
+    if (name === 'TimeoutError' || name === 'AbortError') {
+        return new CliError({
+            code: 'TIMEOUT',
+            message: `No answer from ${hostOf(url)} within ${Math.round(timeoutMilliseconds / 1000)}s.`,
+            exitCode: EXIT_CODES.unavailable,
+            hint: 'Try again, or wait longer with --timeout <seconds>.',
+            cause: error
+        });
+    }
+    const cause = error instanceof Error ? error.cause : undefined;
+    const reason = (typeof cause?.code === 'string' && cause.code) ||
+        (typeof cause?.message === 'string' && cause.message) ||
+        (error instanceof Error ? error.message : String(error));
+    return new CliError({
+        code: 'NETWORK_ERROR',
+        message: `Cannot reach ${hostOf(url)}: ${reason}`,
+        exitCode: EXIT_CODES.unavailable,
+        hint: 'Check the connection (and WIDGETIC_API_URL or WIDGETIC_MCP_URL if one is set), then try again.',
+        cause: error
+    });
+}

package/dist/input.js

@@ -0,0 +1,37 @@
+import { resolve } from 'node:path';
+import { readAll } from "./environment.js";
+import { usageError } from "./errors.js";
+/**
+ * A document given on the command line (`--data`, `--input`): the JSON itself, `@path` for a file that holds it, or
+ * `-` for what is on standard input. It has to be a JSON object: every body and every tool input of the contracts is one.
+ */
+export async function readDocument(environment, source, flag) {
+    let text;
+    if (source === '-') {
+        text = await readAll(environment.stdin);
+    }
+    else if (source.startsWith('@')) {
+        const path = resolve(environment.cwd, source.slice(1));
+        try {
+            text = new TextDecoder().decode(await environment.fs.readFile(path));
+        }
+        catch {
+            throw usageError(`--${flag}: the file ${path} cannot be read.`);
+        }
+    }
+    else {
+        text = source;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw usageError(`--${flag} is not valid JSON: ${reason}`, 'Give the document itself, @path/to/file.json, or - to read it from standard input.');
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw usageError(`--${flag} must be a JSON object ({ ... }).`);
+    }
+    return parsed;
+}

package/dist/main.js

@@ -0,0 +1,30 @@
+import { run } from "./cli.js";
+import { realEnvironment } from "./environment.js";
+import { offerUpdate, startUpdateCheck } from "./update/offer.js";
+/**
+ * One run of the program as the process does it: the command, and after it, when a newer version exists, the question
+ * whether to update (`src/update/offer.ts`). The look for that version starts first and goes on beside the command, so
+ * the command is not slower for it; the question comes last, so it cannot change what the command printed or the exit
+ * code it returns. `run` stays the command alone: it is what the tests of every command call.
+ */
+export async function runProcess(argv, environment) {
+    const pendingUpdateCheck = startUpdateCheck(environment, argv);
+    const exitCode = await run(argv, environment);
+    await offerUpdate(environment, pendingUpdateCheck, exitCode);
+    return exitCode;
+}
+/**
+ * The process entry (called by bin/widgetic.js): runs the program against the real environment and sets the exit code.
+ * `process.exitCode` is set rather than `process.exit()` called, so what was written to a pipe is flushed first.
+ */
+export async function main(argv = process.argv.slice(2)) {
+    // `widgetic ... | head` closes the pipe early: that is not an error of ours.
+    process.stdout.on('error', (error) => {
+        if (error.code === 'EPIPE')
+            process.exit(0);
+        throw error;
+    });
+    // Ctrl-C ends the run at once, the way a shell expects (128 + SIGINT).
+    process.once('SIGINT', () => process.exit(130));
+    process.exitCode = await runProcess(argv, realEnvironment());
+}

package/dist/manifest/load.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { MANIFEST_FORMAT } from "./types.js";
+/**
+ * Reads the manifests `npm run generate` wrote into `generated/` (one folder above `src/` and `dist/` alike), once
+ * each and only when a command needs them: `widgetic auth status` never reads a 500 KB description of the API.
+ */
+function readGenerated(file) {
+    const url = new URL(`../../generated/${file}`, import.meta.url);
+    let text;
+    try {
+        text = readFileSync(url, 'utf8');
+    }
+    catch {
+        throw new Error(`generated/${file} is missing: this build of @widgetic/cli is incomplete. Run \`npm run generate\` (or reinstall the package).`);
+    }
+    return JSON.parse(text);
+}
+function checkedFormat(manifest, file) {
+    if (manifest.format !== MANIFEST_FORMAT) {
+        throw new Error(`generated/${file} has format ${manifest.format}, and this program reads format ${MANIFEST_FORMAT}: run \`npm run generate\`.`);
+    }
+    return manifest;
+}
+let rest;
+let mcp;
+let contracts;
+export function loadRestManifest() {
+    rest ??= checkedFormat(readGenerated('rest-manifest.json'), 'rest-manifest.json');
+    return rest;
+}
+export function loadMcpManifest() {
+    mcp ??= checkedFormat(readGenerated('mcp-manifest.json'), 'mcp-manifest.json');
+    return mcp;
+}
+/** What the contracts the program was generated from say about themselves (`widgetic doctor` prints it). */
+export function loadContractsInfo() {
+    contracts ??= readGenerated('contracts.json');
+    return contracts;
+}

package/dist/manifest/types.js

@@ -0,0 +1,14 @@
+/**
+ * The shapes of the two command manifests.
+ *
+ * `scripts/generate.ts` writes them into `generated/` from the installed `@widgetic/api-contracts` (the public OpenAPI
+ * description and the MCP tool contract the gateway publishes), and the program reads them at run time to build its
+ * commands. Nothing in a manifest is typed by hand: a command exists because the contract has an operation or a tool,
+ * and a flag exists because the contract has a parameter or a property. The few rules that are ours (the names, the
+ * aliases, which command asks before it runs) are in `scripts/lib/` and pinned by tests.
+ *
+ * This file is imported by the generator and by the program, so a manifest cannot be written in one shape and read in
+ * another.
+ */
+/** The version of the manifest format. The program refuses a manifest of another version. */
+export const MANIFEST_FORMAT = 1;

package/dist/mcp/plan.js

@@ -0,0 +1,32 @@
+import { readDocument } from "../input.js";
+import { redactSecrets } from "../secrets.js";
+import { namedByFlag, requireValid } from "../validate.js";
+import { cliIdentity } from "../version.js";
+export async function planMcpCall(plan) {
+    const { environment, command, values, input } = plan;
+    const args = input === undefined ? {} : await readDocument(environment, input, 'input');
+    for (const flag of command.flags) {
+        if (values.has(flag.flag))
+            args[flag.property] = values.get(flag.flag);
+    }
+    // What the CLI does when it is not told: a build is a draft (`--publish` makes it public). Only where the person gave nothing, in a flag or in the document.
+    for (const flag of command.flags) {
+        if (flag.cliDefault !== undefined && !(flag.property in args))
+            args[flag.property] = flag.cliDefault;
+    }
+    const flagOf = new Map(command.flags.map((flag) => [flag.property, flag.flag]));
+    await requireValid(command.inputSchema, args, `The input of ${command.tool}`, (path) => namedByFlag(path, flagOf));
+    return { command, arguments: args };
+}
+/** What `--dry-run` prints: the call exactly as it would be made, with the key left out. */
+export function describeMcpPlan(plan, settings) {
+    return {
+        dryRun: true,
+        method: 'tools/call',
+        url: settings.mcpUrl,
+        headers: { authorization: 'Bearer [redacted]', 'x-sdk-version': cliIdentity() },
+        tool: plan.command.tool,
+        // No tool takes a secret today; one that does keeps it out of this print, as a REST document does.
+        arguments: redactSecrets(plan.arguments, plan.command.inputSchema)
+    };
+}

package/dist/mcp/register.js

@@ -0,0 +1,112 @@
+import { Option } from 'commander';
+import { resolveSettings, timeoutMilliseconds } from "../config.js";
+import { confirmOrStop } from "../confirm.js";
+import { noteContractDifference } from "../contract-note.js";
+import { requireApiKey } from "../credentials.js";
+import { addCommonOptions, addFlag, commandHelp, readCommon, readFlags } from "../options.js";
+import { printResult } from "../output.js";
+import { isWaitTool, WAIT_OVERLAY } from "../overlay.js";
+import { retryNotifier, withRetries } from "../retry.js";
+import { describeMcpPlan, planMcpCall } from "./plan.js";
+import { McpConnection, refusalOf } from "./session.js";
+import { waitForBuild } from "./wait.js";
+/**
+ * The `mcp` namespace: one command for every tool of the Widgetic MCP server, built from the tool contract the
+ * gateway publishes. A command is the tool name in kebab case; an argument that is a string, a number, a choice, a
+ * boolean or a list of strings is a flag, and `--input` takes the whole document (and the arguments that are objects).
+ */
+const SCOPE_HEADINGS = {
+    read: 'Read (look at what exists):',
+    write: 'Write (build and edit):',
+    publish: 'Publish (make something public):',
+    delete: 'Delete:'
+};
+/** What the question before a tool that asks says it does: a tool the CLI does not know (called with `mcp call`) could be anything. */
+function whatItDoes(command) {
+    if (command.destructive)
+        return 'deletes or overwrites something';
+    if (command.scopes.length === 0)
+        return 'is not a tool this CLI knows, so it cannot tell what it changes';
+    return 'makes something public or removes it';
+}
+/** What a tool's answer is, printed: the data of the tool; without data, its text. */
+function printOutcome(environment, outcome, json) {
+    if (outcome.structured !== undefined) {
+        printResult(environment, outcome.structured, json);
+        return;
+    }
+    // A tool that answers in words only: a program still gets JSON.
+    printResult(environment, json ? { text: outcome.text } : outcome.text, json);
+}
+/** Runs one tool command: plan and check, then (unless `--dry-run`) confirm, connect, call, optionally wait, print. */
+export async function runMcpCommand(run, command, node, bindings) {
+    const { environment, manifest } = run;
+    const common = readCommon(node);
+    const values = readFlags(node, bindings);
+    const options = node.opts();
+    const input = typeof options.input === 'string' ? options.input : undefined;
+    const waits = options.wait === true;
+    const settings = resolveSettings(environment, { profile: common.profile });
+    const plan = await planMcpCall({ environment, command, values, input });
+    if (common.dryRun) {
+        printResult(environment, describeMcpPlan(plan, settings), common.json);
+        return;
+    }
+    if (command.confirm) {
+        await confirmOrStop(environment, {
+            what: `${command.tool} ${whatItDoes(command)}`,
+            yes: common.yes,
+            json: common.json
+        });
+    }
+    const key = await requireApiKey(environment, settings);
+    const connection = new McpConnection(environment, settings, { apiKey: key.apiKey, source: key.source }, timeoutMilliseconds(common.timeout));
+    try {
+        // A call that cannot do anything twice is repeated after a lost answer; one that starts a build or edits is not.
+        const safeToRepeat = command.readOnly || command.idempotent;
+        let outcome = await withRetries(environment, { safeToRepeat }, async () => {
+            const answered = await connection.call(command.tool, plan.arguments);
+            if (answered.isError)
+                throw refusalOf(answered);
+            return answered;
+        }, retryNotifier(environment, common.json));
+        await noteContractDifference(environment, settings, {
+            server: connection.serverVersion,
+            expected: manifest.contractVersion,
+            json: common.json
+        });
+        if (waits)
+            outcome = await waitForBuild(environment, connection, outcome, common.json);
+        printOutcome(environment, outcome, common.json);
+    }
+    finally {
+        await connection.close();
+    }
+}
+/** Adds the command of one tool under `parent` and returns it. */
+export function registerMcpCommand(parent, command, run) {
+    const node = parent
+        .command(command.name)
+        .summary(command.title)
+        .description(commandHelp(command.title, command.description, `widgetic schema mcp ${command.name}`));
+    node.helpGroup(SCOPE_HEADINGS[command.scopeGroup]);
+    const bindings = command.flags.map((flag) => addFlag(node, flag, { mandatory: false, group: 'Arguments of the tool:' }));
+    addCommonOptions(node, { asks: command.confirm, document: 'input' });
+    if (isWaitTool(command.tool)) {
+        node.addOption(new Option('--wait', `Keep asking ${WAIT_OVERLAY.pollTool} until the build is finished, and print the finished widget (up to ${Math.round(WAIT_OVERLAY.defaultMaxSeconds / 60)} minutes).`).helpGroup('Common options:'));
+    }
+    node.action(async () => {
+        await runMcpCommand(run, command, node, bindings);
+    });
+    return node;
+}
+/** Adds one command for every tool of the manifest under `mcp`, listed by what they do to your account: read first, delete last. */
+export function registerMcpCommands(mcp, manifest, environment) {
+    const run = { environment, manifest };
+    for (const scopeGroup of Object.keys(SCOPE_HEADINGS)) {
+        for (const command of manifest.commands) {
+            if (command.scopeGroup === scopeGroup)
+                registerMcpCommand(mcp, command, run);
+        }
+    }
+}