@miakapp/cli 4.0.0-alpha.3 → 4.0.0-alpha.5

package/dist/main.js

@@ -0,0 +1,698 @@
+/**
+ * Agent-first command surface.
+ *
+ * The CLI builds, validates, publishes and rolls back one home component. Git
+ * stays the user's: this tool never writes history, never rewrites sources it
+ * did not generate and never invents a control-plane endpoint. Every command is
+ * a pure function of the project file, the artifact bytes on disk and the
+ * arguments it was given.
+ *
+ * Two properties matter more than ergonomics here, because the usual caller is
+ * a coding agent rather than a person:
+ *
+ * - one stable exit code and one stable failure kind per outcome (see
+ *   {@link EXIT_CODE}), so a wrapper decides without parsing prose;
+ * - `--json`, which prints exactly one closed object on stdout.
+ */
+import { installPack } from './agent-pack.js';
+import { CLI_VERSION } from './version.js';
+import { prepareArtifact } from './artifact.js';
+import { exchangePublisherToken, fetchDiscovery } from './control-plane.js';
+import { discoverFlows, inventoryJson } from './discovery.js';
+import { CliError, EXIT_CODE, artifactError, authorizationError, projectError, usageError, } from './errors.js';
+import { isDigest, isRelease, REQUIREMENT_KINDS } from './internal/names.js';
+import { PROJECT_FILE, PROJECT_SCHEMA, findProjectFile, parseProject } from './project.js';
+import { activateRelease, publish, readRelease, readUpload, } from './publication.js';
+export { CLI_VERSION };
+/**
+ * The Home Key is read from the environment only. A secret passed as an
+ * argument would land in shell history, in a process listing and in most CI
+ * logs, so no command accepts one.
+ */
+export const HOME_KEY_VARIABLE = 'MIAKAPP_HOME_KEY';
+const USAGE = `miakapp ${CLI_VERSION} — build, publish and roll back a Miakapp home component
+
+Usage
+  miakapp <command> [options]
+
+Commands
+  docs start              Print the complete agent guide bundled with this CLI
+  init                    Write ${PROJECT_FILE} in the current directory
+  agent-pack              Install the guide and the MCP wiring into a repository
+  discover                Inventory an existing Node-RED installation offline
+  check                   Validate the project and the artifact offline
+  publish                 Upload, finalize and activate the built artifact
+  activate                Activate an already finalized digest at a new generation
+  rollback                Alias of activate, for returning to a known-good digest
+  release <sha256>        Read one finalized release record
+  upload <uploadId>       Read one upload status, to reconcile a lost request
+  mcp                     Serve these commands over MCP on stdio
+  help                    Print this text
+  version                 Print the CLI version
+
+Common options
+  --json                  Print one machine-readable object on stdout
+  --project <dir>         Start the ${PROJECT_FILE} search here (default: cwd)
+
+publish options
+  --expected-generation <n>   Generation the pointer is expected to hold (required)
+  --generation <n>            Generation to publish (default: expected + 1)
+  --release <name>            Override component.release from ${PROJECT_FILE}
+
+activate / rollback options
+  --sha256 <digest>           Finalized artifact digest (required)
+  --expected-generation <n>   Generation the pointer is expected to hold (required)
+  --generation <n>            Generation to publish (default: expected + 1)
+
+discover options
+  --flows <path>              Node-RED flows export to read (required)
+
+mcp options
+  (none)                      Reads JSON-RPC on stdin, writes it on stdout. Every
+                              command above becomes one tool; publish, activate
+                              and rollback additionally require confirm: true.
+
+agent-pack options
+  --dir <path>                Repository to install into (default: cwd)
+
+init options
+  --home <homeId>             Home ID to write into ${PROJECT_FILE} (required)
+  --control-plane <https url> Control-plane issuer (required)
+  --artifact <path>           Built artifact path (default: dist/component.js)
+  --release <name>            Initial release name (default: 0.1.0)
+
+Environment
+  ${HOME_KEY_VARIABLE}   Home Key with the components:publish scope. Required by
+                     publish, activate, rollback, release and upload. It is never
+                     accepted as an argument and never printed.
+
+Exit codes
+  0 success        1 usage        2 project      3 artifact
+  4 authorization  5 contract     6 conflict     7 unknown outcome
+`;
+const GLOBAL_FLAGS = ['json'];
+const GLOBAL_OPTIONS = ['project'];
+/** Exported so the MCP surface can be proved to expose every option, and no other. */
+export const COMMAND_OPTIONS = {
+    docs: [],
+    init: ['home', 'control-plane', 'artifact', 'release'],
+    'agent-pack': ['dir'],
+    discover: ['flows'],
+    check: [],
+    publish: ['expected-generation', 'generation', 'release'],
+    activate: ['sha256', 'expected-generation', 'generation'],
+    rollback: ['sha256', 'expected-generation', 'generation'],
+    release: [],
+    upload: [],
+    mcp: [],
+    help: [],
+    version: [],
+};
+/**
+ * Parses `--name value`, `--name=value` and bare flags.
+ *
+ * Options are a closed set per command: an unrecognized one is a usage error
+ * rather than a silently ignored argument, so a mistyped flag can never turn a
+ * publication into a different publication.
+ */
+export function parseArguments(argv) {
+    const first = argv[0];
+    if (first === undefined || first === '--help' || first === '-h') {
+        return { command: 'help', options: new Map(), flags: new Set(), positional: [] };
+    }
+    if (first === '--version' || first === '-v') {
+        return { command: 'version', options: new Map(), flags: new Set(), positional: [] };
+    }
+    if (first.startsWith('-'))
+        throw usageError(`Expected a command, received ${first}`);
+    const command = first;
+    const allowed = COMMAND_OPTIONS[command];
+    if (allowed === undefined) {
+        throw usageError(`Unknown command: ${command}`, 'Run miakapp help for the command list.');
+    }
+    const options = new Map();
+    const flags = new Set();
+    const positional = [];
+    for (let index = 1; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (!argument.startsWith('--')) {
+            positional.push(argument);
+            continue;
+        }
+        const separator = argument.indexOf('=');
+        const name = separator === -1 ? argument.slice(2) : argument.slice(2, separator);
+        if (name === '')
+            throw usageError('Encountered a bare -- separator');
+        if (GLOBAL_FLAGS.includes(name)) {
+            if (separator !== -1)
+                throw usageError(`--${name} does not take a value`);
+            flags.add(name);
+            continue;
+        }
+        const known = GLOBAL_OPTIONS.includes(name) || allowed.includes(name);
+        if (!known) {
+            throw usageError(`Unknown option --${name} for ${command}`, 'Run miakapp help for the options this command accepts.');
+        }
+        if (options.has(name))
+            throw usageError(`--${name} was given twice`);
+        if (separator !== -1) {
+            options.set(name, argument.slice(separator + 1));
+            continue;
+        }
+        const value = argv[index + 1];
+        if (value === undefined || value.startsWith('--')) {
+            throw usageError(`--${name} requires a value`);
+        }
+        options.set(name, value);
+        index += 1;
+    }
+    return { command, options, flags, positional };
+}
+function requiredOption(invocation, name) {
+    const value = invocation.options.get(name);
+    if (value === undefined || value === '')
+        throw usageError(`--${name} is required`);
+    return value;
+}
+function generationOption(invocation, name) {
+    const raw = requiredOption(invocation, name);
+    if (!/^(0|[1-9][0-9]*)$/.test(raw)) {
+        throw usageError(`--${name} must be a decimal non-negative integer, received ${raw}`);
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value))
+        throw usageError(`--${name} is above the safe integer range`);
+    return value;
+}
+/** `--generation` defaults to one above the expected generation, never higher. */
+function generationPair(invocation) {
+    const expectedGeneration = generationOption(invocation, 'expected-generation');
+    const generation = invocation.options.has('generation')
+        ? generationOption(invocation, 'generation')
+        : expectedGeneration + 1;
+    if (generation <= expectedGeneration) {
+        throw usageError('--generation must be strictly above --expected-generation');
+    }
+    return { expectedGeneration, generation };
+}
+function digestOption(invocation, name) {
+    const value = requiredOption(invocation, name);
+    if (!isDigest(value)) {
+        throw usageError(`--${name} must be a SHA-256 digest as 43 base64url characters`);
+    }
+    return value;
+}
+function homeKey(host) {
+    const value = host.env(HOME_KEY_VARIABLE);
+    if (value === undefined || value === '') {
+        throw authorizationError(`${HOME_KEY_VARIABLE} is not set`, `Export a Home Key holding components:publish as ${HOME_KEY_VARIABLE}. `
+            + 'It is never accepted as a command-line argument.');
+    }
+    return value;
+}
+async function nodeFileSystem() {
+    const fs = await import('node:fs/promises');
+    return {
+        async read(path) {
+            return new Uint8Array(await fs.readFile(path));
+        },
+        async write(path, bytes) {
+            await fs.writeFile(path, bytes, { flag: 'wx' });
+        },
+        async replace(path, bytes) {
+            await fs.writeFile(path, bytes);
+        },
+        async makeDirectory(path) {
+            await fs.mkdir(path, { recursive: true });
+        },
+        async exists(path) {
+            try {
+                await fs.access(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+async function files(host) {
+    return host.files ?? await nodeFileSystem();
+}
+async function loadProject(host, invocation) {
+    const filesystem = await files(host);
+    const start = invocation.options.get('project') ?? host.cwd();
+    const path = await findProjectFile(start, (candidate) => filesystem.exists(candidate));
+    const root = path.slice(0, path.length - PROJECT_FILE.length - 1);
+    let source;
+    try {
+        source = new TextDecoder('utf-8', { fatal: true }).decode(await filesystem.read(path));
+    }
+    catch {
+        throw projectError(`${path} is not readable as UTF-8 text`);
+    }
+    return parseProject(root, source);
+}
+async function loadArtifact(host, project) {
+    const filesystem = await files(host);
+    if (!await filesystem.exists(project.artifactPath)) {
+        throw artifactError(`No artifact at ${project.artifactPath}`, 'Build the component before publishing; the CLI never bundles sources itself.');
+    }
+    return prepareArtifact(await filesystem.read(project.artifactPath));
+}
+async function publicationTarget(host, project) {
+    const key = homeKey(host);
+    const options = host.fetch === undefined ? {} : { fetch: host.fetch };
+    const discovery = await fetchDiscovery({ issuer: project.issuer, ...options });
+    const token = await exchangePublisherToken(discovery, key, options);
+    return { issuer: discovery.issuer, homeId: project.homeId, token: token.accessToken, ...options };
+}
+function requirementFields(requires) {
+    return REQUIREMENT_KINDS.map((kind) => [`requires.${kind}`, requires[kind]]);
+}
+function pointerResult(summary, pointer) {
+    return {
+        summary,
+        fields: [
+            ['home', pointer.homeId],
+            ['generation', pointer.generation],
+            ['release', pointer.release],
+            ['sha256', pointer.sha256],
+            ['size', pointer.size],
+            ['url', pointer.url],
+            ...requirementFields(pointer.requires),
+        ],
+        json: {
+            home_id: pointer.homeId,
+            generation: pointer.generation,
+            release: pointer.release,
+            abi: pointer.abi,
+            url: pointer.url,
+            sha256: pointer.sha256,
+            size: pointer.size,
+            requires: pointer.requires,
+        },
+    };
+}
+function projectTemplate(fields) {
+    return `schema: ${PROJECT_SCHEMA}
+home: ${fields.home}
+control_plane: ${fields.controlPlane}
+
+component:
+  artifact: ${fields.artifact}
+  release: ${fields.release}
+  requires:
+    state_read: []
+    event_subscribe: []
+    event_publish: []
+    call: []
+    presentation: []
+`;
+}
+async function runInit(host, invocation) {
+    const filesystem = await files(host);
+    const root = invocation.options.get('project') ?? host.cwd();
+    const path = `${root}/${PROJECT_FILE}`;
+    if (await filesystem.exists(path)) {
+        throw projectError(`${path} already exists`, 'The CLI never overwrites a project file; edit it or remove it first.');
+    }
+    const release = invocation.options.get('release') ?? '0.1.0';
+    if (!isRelease(release)) {
+        throw usageError('--release must be 1..64 UTF-8 bytes without control characters');
+    }
+    const source = projectTemplate({
+        home: requiredOption(invocation, 'home'),
+        controlPlane: requiredOption(invocation, 'control-plane'),
+        artifact: invocation.options.get('artifact') ?? 'dist/component.js',
+        release,
+    });
+    // Parsed before it is written, so init can never emit a file check rejects.
+    parseProject(root, source);
+    await filesystem.write(path, new TextEncoder().encode(source));
+    return {
+        summary: `Wrote ${path}`,
+        fields: [['project', path]],
+        json: { project: path, schema: PROJECT_SCHEMA },
+    };
+}
+/**
+ * Absolute path of the guide shipped with this package.
+ *
+ * Resolved from this module rather than from the working directory: the pack is
+ * installed into someone else's repository, and the guide has to come from the
+ * installed CLI wherever that repository happens to be.
+ *
+ * Exported so a test reads the same path the command does. A test that seeded a
+ * fixture at a path the command never opens would prove nothing.
+ */
+export async function guideAssetPath() {
+    const { fileURLToPath } = await import('node:url');
+    return fileURLToPath(new URL('../assets/agent-guide.md', import.meta.url));
+}
+/**
+ * Gives an agent its complete starting contract without requiring a repository,
+ * a network request or an MCP client. The onboarding page can therefore hand a
+ * person one stable command and the installed CLI remains the source of truth.
+ */
+async function runDocs(host, invocation) {
+    if (invocation.positional.length !== 1 || invocation.positional[0] !== 'start') {
+        throw usageError('docs requires the topic start', 'Run miakapp docs start to print the complete agent guide.');
+    }
+    const path = await guideAssetPath();
+    let guide;
+    try {
+        const filesystem = await files(host);
+        guide = new TextDecoder('utf-8', { fatal: true }).decode(await filesystem.read(path));
+    }
+    catch {
+        throw projectError(`The packaged guide is missing or unreadable at ${path}`, 'Reinstall @miakapp/cli: the guide is bundled with the package and opens no network connection.');
+    }
+    return {
+        summary: 'Miakapp agent guide',
+        fields: [],
+        json: { topic: 'start', guide },
+        text: guide.endsWith('\n') ? guide : `${guide}\n`,
+    };
+}
+/**
+ * Installs the agent pack. Like `discover`, it loads no project file: the
+ * repository it prepares is usually one that has no V4 project yet.
+ */
+async function runAgentPack(host, invocation) {
+    const filesystem = await files(host);
+    const root = invocation.options.get('dir') ?? host.cwd();
+    if (!await filesystem.exists(root)) {
+        throw projectError(`No directory at ${root}`, 'Point --dir at the repository to install into, or run the command inside it.');
+    }
+    const guidePath = await guideAssetPath();
+    let guide;
+    try {
+        guide = new TextDecoder('utf-8', { fatal: true }).decode(await filesystem.read(guidePath));
+    }
+    catch {
+        throw projectError(`The packaged guide is missing or unreadable at ${guidePath}`, 'Reinstall @miakapp/cli: the pack copies the guide out of the package, never off the network.');
+    }
+    const result = await installPack(filesystem, root, guide);
+    const changed = result.files.filter((entry) => entry.action !== 'unchanged').length;
+    return {
+        summary: changed === 0
+            ? `The pack in ${root} is already current`
+            : `Installed the agent pack in ${root}`,
+        fields: result.files.map((entry) => [entry.path, entry.action]),
+        json: {
+            root: result.root,
+            changed,
+            files: result.files.map((entry) => ({ path: entry.path, action: entry.action })),
+        },
+    };
+}
+/**
+ * Reads an existing installation. `discover` never loads the project file: an
+ * agent runs it on a house that has no V4 project yet, which is the whole point
+ * of the command.
+ */
+async function runDiscover(host, invocation) {
+    const path = requiredOption(invocation, 'flows');
+    const filesystem = await files(host);
+    if (!await filesystem.exists(path)) {
+        throw projectError(`No flows export at ${path}`, 'Point --flows at the Node-RED flows.json, or at an Export > All flows download.');
+    }
+    const inventory = discoverFlows(await filesystem.read(path));
+    return {
+        summary: discoverSummary(inventory),
+        fields: discoverFields(inventory),
+        json: inventoryJson(inventory),
+    };
+}
+function counted(count, singular, plural) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}
+function discoverSummary(inventory) {
+    const critical = inventory.findings.filter((item) => item.severity === 'critical').length;
+    const census = [
+        counted(inventory.nodeCount, 'node', 'nodes'),
+        counted(inventory.flows.length, 'flow', 'flows'),
+        counted(inventory.brokers.length, 'broker', 'brokers'),
+        counted(inventory.state.length, 'state path', 'state paths'),
+        counted(inventory.actions.length, 'action', 'actions'),
+    ].join(', ');
+    return critical === 0
+        ? census
+        : `${census} — ${counted(critical, 'finding', 'findings')} to settle before migrating`;
+}
+function discoverFields(inventory) {
+    const fields = [];
+    for (const home of inventory.homes) {
+        fields.push([`home.${home.homeId}`, `coordinator ${home.coordinatorId}`]);
+    }
+    for (const broker of inventory.brokers) {
+        const address = broker.port === undefined ? broker.host : `${broker.host}:${broker.port}`;
+        fields.push([
+            `broker.${broker.name === '' ? broker.id : broker.name}`,
+            `${address} tls=${broker.tls} in=${broker.subscribes.length} out=${broker.publishes.length}`,
+        ]);
+    }
+    for (const tab of inventory.flows) {
+        fields.push([`flow.${tab.label === '' ? tab.id : tab.label}`, `${tab.nodeCount} nodes`]);
+    }
+    if (inventory.state.length > 0) {
+        fields.push(['state', inventory.state.map((entry) => entry.path)]);
+    }
+    if (inventory.actions.length > 0) {
+        fields.push(['actions', inventory.actions.map((entry) => entry.inputId)]);
+    }
+    if (inventory.unmodelled.length > 0) {
+        fields.push(['unmodelled', inventory.unmodelled.map((entry) => `${entry.type}×${entry.count}`)]);
+    }
+    for (const item of inventory.findings) {
+        fields.push([item.severity, item.detail]);
+    }
+    return fields;
+}
+async function runCheck(host, invocation) {
+    const project = await loadProject(host, invocation);
+    const artifact = await loadArtifact(host, project);
+    const filesystem = await files(host);
+    const coordinator = project.coordinatorEntry;
+    if (coordinator !== undefined && !await filesystem.exists(coordinator)) {
+        throw projectError(`coordinator.entry does not exist: ${coordinator}`);
+    }
+    return {
+        summary: `${project.homeId} release ${project.release} is publishable`,
+        fields: [
+            ['home', project.homeId],
+            ['control_plane', project.issuer],
+            ['release', project.release],
+            ['artifact', project.artifactPath],
+            ['sha256', artifact.sha256],
+            ['size', artifact.size],
+            ['tokens', artifact.tokens],
+            ...requirementFields(project.requires),
+        ],
+        json: {
+            home_id: project.homeId,
+            control_plane: project.issuer,
+            release: project.release,
+            artifact: project.artifactPath,
+            sha256: artifact.sha256,
+            size: artifact.size,
+            tokens: artifact.tokens,
+            requires: project.requires,
+        },
+    };
+}
+async function runPublish(host, invocation) {
+    const { expectedGeneration, generation } = generationPair(invocation);
+    const project = await loadProject(host, invocation);
+    const release = invocation.options.get('release') ?? project.release;
+    if (!isRelease(release)) {
+        throw usageError('--release must be 1..64 UTF-8 bytes without control characters');
+    }
+    const artifact = await loadArtifact(host, project);
+    const target = await publicationTarget(host, project);
+    const { pointer } = await publish(target, artifact, {
+        release,
+        requires: project.requires,
+        expectedGeneration,
+        generation,
+    });
+    return pointerResult(`Published ${release} as generation ${pointer.generation}`, pointer);
+}
+async function runActivate(host, invocation) {
+    const sha256 = digestOption(invocation, 'sha256');
+    const { expectedGeneration, generation } = generationPair(invocation);
+    const project = await loadProject(host, invocation);
+    const target = await publicationTarget(host, project);
+    // Activation is checked against a readable finalized record first, so a typo
+    // in a digest fails as an artifact error instead of spending a CAS attempt.
+    const existing = await readRelease(target, sha256);
+    if (existing === undefined) {
+        throw artifactError(`No finalized release for ${sha256}`, 'Activate only a digest this home has already published.');
+    }
+    const pointer = await activateRelease(target, { sha256, expectedGeneration, generation });
+    return pointerResult(`Activated ${existing.release} as generation ${pointer.generation}`, pointer);
+}
+async function runRelease(host, invocation) {
+    const sha256 = invocation.positional[0];
+    if (sha256 === undefined)
+        throw usageError('release requires one sha256 argument');
+    if (!isDigest(sha256)) {
+        throw usageError('The release digest must be 43 base64url characters');
+    }
+    const project = await loadProject(host, invocation);
+    const target = await publicationTarget(host, project);
+    const record = await readRelease(target, sha256);
+    if (record === undefined) {
+        throw artifactError(`No finalized release for ${sha256}`);
+    }
+    return {
+        summary: `Release ${record.release} finalized at ${record.finalizedAt}`,
+        fields: [
+            ['release', record.release],
+            ['sha256', record.sha256],
+            ['size', record.size],
+            ['finalized_at', record.finalizedAt],
+            ...requirementFields(record.requires),
+        ],
+        json: {
+            release: record.release,
+            abi: record.abi,
+            sha256: record.sha256,
+            size: record.size,
+            requires: record.requires,
+            finalized_at: record.finalizedAt,
+        },
+    };
+}
+async function runUpload(host, invocation) {
+    const uploadId = invocation.positional[0];
+    if (uploadId === undefined)
+        throw usageError('upload requires one uploadId argument');
+    const project = await loadProject(host, invocation);
+    const target = await publicationTarget(host, project);
+    const state = await readUpload(target, uploadId);
+    return {
+        summary: `Upload ${state.uploadId} is ${state.status}`,
+        fields: [
+            ['upload_id', state.uploadId],
+            ['status', state.status],
+            ['release', state.release],
+            ['sha256', state.sha256],
+            ['size', state.size],
+            ['expires_at', state.expiresAt],
+        ],
+        json: {
+            upload_id: state.uploadId,
+            status: state.status,
+            release: state.release,
+            abi: state.abi,
+            sha256: state.sha256,
+            size: state.size,
+            requires: state.requires,
+            expires_at: state.expiresAt,
+        },
+    };
+}
+/**
+ * Runs one parsed invocation.
+ *
+ * Exported for `mcp`, which reaches the same commands without a process: a
+ * tool call and a command line must not be able to diverge.
+ */
+export async function dispatch(host, invocation) {
+    switch (invocation.command) {
+        case 'docs':
+            return await runDocs(host, invocation);
+        case 'init':
+            return await runInit(host, invocation);
+        case 'agent-pack':
+            return await runAgentPack(host, invocation);
+        case 'discover':
+            return await runDiscover(host, invocation);
+        case 'check':
+            return await runCheck(host, invocation);
+        case 'publish':
+            return await runPublish(host, invocation);
+        case 'activate':
+        case 'rollback':
+            return await runActivate(host, invocation);
+        case 'release':
+            return await runRelease(host, invocation);
+        case 'upload':
+            return await runUpload(host, invocation);
+        default:
+            throw usageError(`Unknown command: ${invocation.command}`);
+    }
+}
+function renderText(result) {
+    if (result.text !== undefined)
+        return result.text;
+    const lines = [result.summary];
+    for (const [key, value] of result.fields) {
+        lines.push(`  ${key}: ${Array.isArray(value) ? `[${value.join(', ')}]` : String(value)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderFailure(error, json) {
+    if (json) {
+        return `${JSON.stringify({
+            ok: false,
+            kind: error.kind,
+            exit_code: error.exitCode,
+            message: error.message,
+            ...(error.remedy === undefined ? {} : { remedy: error.remedy }),
+        })}\n`;
+    }
+    const remedy = error.remedy === undefined ? '' : `\n  ${error.remedy}`;
+    return `miakapp: ${error.kind}: ${error.message}${remedy}\n`;
+}
+/**
+ * Runs one invocation and returns its exit code.
+ *
+ * Nothing throws out of this function: an unexpected error becomes
+ * `unknown_outcome`, because a CLI that crashed mid-publication cannot claim
+ * the control plane was left untouched.
+ */
+export async function run(argv, host) {
+    let json = false;
+    try {
+        const invocation = parseArguments(argv);
+        json = invocation.flags.has('json');
+        if (invocation.command === 'help') {
+            host.write(json ? `${JSON.stringify({ ok: true, usage: USAGE })}\n` : USAGE);
+            return EXIT_CODE.success;
+        }
+        if (invocation.command === 'version') {
+            host.write(json ? `${JSON.stringify({ ok: true, version: CLI_VERSION })}\n` : `${CLI_VERSION}\n`);
+            return EXIT_CODE.success;
+        }
+        if (invocation.command === 'mcp') {
+            if (json)
+                throw usageError('mcp does not take --json; the protocol is already JSON-RPC');
+            const input = host.input;
+            if (input === undefined) {
+                throw usageError('mcp needs a request stream on stdin', 'An MCP client starts this command as a subprocess and speaks JSON-RPC over the pipe.');
+            }
+            // Imported here, not at the top: mcp.ts is built on this module, and the
+            // other commands must not pay for a protocol they never speak.
+            const { serve } = await import('./mcp.js');
+            return await serve(host, input);
+        }
+        const result = await dispatch(host, invocation);
+        host.write(json
+            ? `${JSON.stringify({ ok: true, command: invocation.command, ...result.json })}\n`
+            : renderText(result));
+        return EXIT_CODE.success;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            host.writeError(renderFailure(error, json));
+            return error.exitCode;
+        }
+        const message = error instanceof Error ? error.message : 'Unrecognized failure';
+        host.writeError(renderFailure(new CliError('unknown_outcome', `The command ended in an unhandled failure: ${message}`, 'Reconcile with miakapp release or miakapp upload before publishing again.'), json));
+        return EXIT_CODE.unknown_outcome;
+    }
+}
+//# sourceMappingURL=main.js.map