@aisa-one/cli 0.2.4 → 0.5.0

package/dist/commands/tool-input.js

@@ -0,0 +1,220 @@
+import { readFileSync } from "node:fs";
+import { usageError } from "../cli-error.js";
+/**
+ * Resolve one request body from operands, --input, or -f.
+ * Conflicting sources are a usage error and must not dispatch.
+ */
+export async function prepareRouterRequest(kind, operands, options) {
+    const hasInput = options.input !== undefined;
+    const hasFile = options.file !== undefined;
+    const hasOperands = operands.length > 0;
+    if (hasInput && hasFile) {
+        throw usageError("Use either --input or -f/--file, not both");
+    }
+    if ((hasInput || hasFile) && hasOperands) {
+        throw usageError("Do not combine positional arguments with --input or -f/--file");
+    }
+    if ((hasInput || hasFile) && hasSupplementalFlags(kind, options)) {
+        throw usageError("Do not combine --input/-f with field flags; put every field in the JSON request");
+    }
+    if (hasInput) {
+        return fromEnvelope(kind, options.input, " --input");
+    }
+    if (hasFile) {
+        return fromEnvelope(kind, await readRequestFile(options.file), ` -f ${options.file}`);
+    }
+    if (kind === "search") {
+        return buildSearch(operands, options);
+    }
+    if (kind === "schema") {
+        return buildSchema(operands, options);
+    }
+    throw usageError(`${kind} requires --input '<json>' or -f FILE (use -f - for stdin)`);
+}
+async function readRequestFile(path) {
+    if (path === "-") {
+        if (process.stdin.isTTY) {
+            throw usageError("No JSON on stdin. Pipe a request or pass -f FILE");
+        }
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks).toString("utf-8");
+    }
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch (err) {
+        throw usageError(`Cannot read ${path}: ${err.message}`);
+    }
+}
+function fromEnvelope(kind, raw, source) {
+    const text = raw.trim();
+    if (!text) {
+        throw usageError(`Empty JSON request from${source}`);
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw usageError(`Invalid JSON from${source}`);
+    }
+    if (!isPlainObject(value)) {
+        throw usageError(`Request from${source} must be a JSON object`);
+    }
+    validateEnvelope(kind, value);
+    // Send the original text so numeric tokens in arguments are not rewritten.
+    return { body: text, value };
+}
+function buildSearch(operands, options) {
+    if (operands.length !== 1 || !operands[0].trim()) {
+        throw usageError("search requires a query, --input '<json>', or -f FILE");
+    }
+    const request = { query: operands[0] };
+    if (options.limit !== undefined) {
+        request.limit = parseLimit(options.limit);
+    }
+    if (options.provider && options.provider.length > 0) {
+        request.provider_filters = options.provider;
+    }
+    validateEnvelope("search", request);
+    return { body: JSON.stringify(request), value: request };
+}
+function buildSchema(operands, options) {
+    const tools = operands.map((t) => t.trim()).filter(Boolean);
+    if (tools.length === 0) {
+        throw usageError("schema requires one or more tool names, --input '<json>', or -f FILE");
+    }
+    const request = { tools };
+    // Only send include_* when the caller set them so server defaults remain.
+    if (options.includeArgumentsSchema === false) {
+        request.include_arguments_schema = false;
+    }
+    if (options.includeResponseSchema === true) {
+        request.include_response_schema = true;
+    }
+    if (options.includeArgumentsSchema === false && options.includeResponseSchema !== true) {
+        throw usageError("At least one of arguments or response schema must be requested");
+    }
+    validateEnvelope("schema", request);
+    return { body: JSON.stringify(request), value: request };
+}
+function parseLimit(raw) {
+    if (!/^[1-9]\d*$/.test(raw)) {
+        throw usageError("limit must be an integer from 1 to 20");
+    }
+    const n = Number(raw);
+    if (n < 1 || n > 20) {
+        throw usageError("limit must be an integer from 1 to 20");
+    }
+    return n;
+}
+const SEARCH_KEYS = ["query", "known_fields", "provider_filters", "limit"];
+const SCHEMA_KEYS = ["tools", "include_arguments_schema", "include_response_schema"];
+const BATCH_KEYS = ["search_id", "calls"];
+const CALL_KEYS = ["call_id", "tool", "arguments"];
+export function validateEnvelope(kind, value) {
+    if (kind === "search") {
+        rejectUnknownKeys(value, SEARCH_KEYS, "search request");
+        if (typeof value.query !== "string" || value.query.trim().length === 0) {
+            throw usageError("search request requires a non-empty query string");
+        }
+        if (value.query.length > 2000) {
+            throw usageError("query must be at most 2000 characters");
+        }
+        if (value.known_fields !== undefined && !isPlainObject(value.known_fields)) {
+            throw usageError("known_fields must be a JSON object");
+        }
+        if (value.provider_filters !== undefined) {
+            if (!isStringArray(value.provider_filters)) {
+                throw usageError("provider_filters must be an array of strings");
+            }
+            if (value.provider_filters.length > 50) {
+                throw usageError("provider_filters must have at most 50 entries");
+            }
+            if (new Set(value.provider_filters).size !== value.provider_filters.length) {
+                throw usageError("provider_filters must be unique");
+            }
+        }
+        if (value.limit !== undefined) {
+            if (typeof value.limit !== "number" || !Number.isInteger(value.limit) || value.limit < 1 || value.limit > 20) {
+                throw usageError("limit must be an integer from 1 to 20");
+            }
+        }
+        return;
+    }
+    if (kind === "schema") {
+        rejectUnknownKeys(value, SCHEMA_KEYS, "schema request");
+        if (!isStringArray(value.tools) || value.tools.length < 1 || value.tools.length > 20) {
+            throw usageError("schema request requires tools: 1–20 non-empty strings");
+        }
+        if (new Set(value.tools).size !== value.tools.length) {
+            throw usageError("schema tools must be unique");
+        }
+        if (value.tools.some((t) => t.trim().length === 0 || /\s/.test(t[0]) || /\s/.test(t[t.length - 1]))) {
+            throw usageError("each tool name must be a non-empty string without surrounding whitespace");
+        }
+        const includeArgs = value.include_arguments_schema;
+        const includeResp = value.include_response_schema;
+        if (includeArgs !== undefined && typeof includeArgs !== "boolean") {
+            throw usageError("include_arguments_schema must be a boolean");
+        }
+        if (includeResp !== undefined && typeof includeResp !== "boolean") {
+            throw usageError("include_response_schema must be a boolean");
+        }
+        if (includeArgs === false && includeResp === false) {
+            throw usageError("At least one of arguments or response schema must be requested");
+        }
+        return;
+    }
+    rejectUnknownKeys(value, BATCH_KEYS, "quote/call request");
+    if (!Array.isArray(value.calls) || value.calls.length < 1 || value.calls.length > 20) {
+        throw usageError("quote/call request requires calls: 1–20 items");
+    }
+    if (value.search_id !== undefined && typeof value.search_id !== "string") {
+        throw usageError("search_id must be a string");
+    }
+    const callIds = [];
+    for (const [i, call] of value.calls.entries()) {
+        if (!isPlainObject(call)) {
+            throw usageError(`calls[${i}] must be an object`);
+        }
+        rejectUnknownKeys(call, CALL_KEYS, `calls[${i}]`);
+        if (typeof call.call_id !== "string" || call.call_id.length < 1 || call.call_id.length > 128) {
+            throw usageError(`calls[${i}].call_id must be a string of 1–128 characters`);
+        }
+        if (typeof call.tool !== "string" || call.tool.length < 1) {
+            throw usageError(`calls[${i}].tool must be a non-empty string`);
+        }
+        if (!isPlainObject(call.arguments)) {
+            throw usageError(`calls[${i}].arguments must be a JSON object`);
+        }
+        callIds.push(call.call_id);
+    }
+    if (new Set(callIds).size !== callIds.length) {
+        throw usageError("call_id values must be unique within the batch");
+    }
+}
+function rejectUnknownKeys(value, allowed, label) {
+    const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+    if (extra.length > 0) {
+        throw usageError(`${label} has unknown field(s): ${extra.join(", ")}`);
+    }
+}
+function hasSupplementalFlags(kind, options) {
+    if (kind === "search") {
+        return options.limit !== undefined || (options.provider !== undefined && options.provider.length > 0);
+    }
+    if (kind === "schema") {
+        return options.includeArgumentsSchema !== undefined || options.includeResponseSchema !== undefined;
+    }
+    return false;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}

package/dist/commands/tools.d.ts

@@ -0,0 +1,12 @@
+import { type RouterIoOptions } from "./tool-input.js";
+export declare function searchAction(query: string | undefined, options: RouterIoOptions): Promise<void>;
+export declare function schemaAction(tools: string[] | undefined, options: RouterIoOptions): Promise<void>;
+export declare function quoteAction(options: RouterIoOptions): Promise<void>;
+export declare function callAction(options: RouterIoOptions): Promise<void>;
+/** Unmodified application body. No parse/stringify round trip. */
+export declare function writeRawStdout(raw: string): void;
+/**
+ * Partial batch: any failed item in a 200 envelope. Counts are small integers
+ * so a structural parse is safe; the raw body has already been written for --json.
+ */
+export declare function batchHasFailure(raw: string): boolean;

package/dist/commands/tools.js

@@ -0,0 +1,307 @@
+import ora from "ora";
+import chalk from "chalk";
+import { getApiKey } from "../config.js";
+import { ENV_VAR_NAME } from "../constants.js";
+import { CliError, EXIT_PARTIAL, EXIT_TRANSPORT, transportError } from "../cli-error.js";
+import { routerPost } from "../router.js";
+import { error as printError } from "../utils/display.js";
+import { numberToken, parseJsonKeepingNumberTokens } from "../json-text.js";
+import { projectMcpIdentifiersToCli } from "../cli-guidance.js";
+import { prepareRouterRequest, } from "./tool-input.js";
+export async function searchAction(query, options) {
+    const operands = query ? [query] : [];
+    await runToolCommand("search", operands, options, { auth: "optional" });
+}
+export async function schemaAction(tools, options) {
+    await runToolCommand("schema", tools ?? [], options, { auth: "optional" });
+}
+export async function quoteAction(options) {
+    await runToolCommand("quote", [], options, { auth: "required" });
+}
+export async function callAction(options) {
+    await runToolCommand("call", [], options, { auth: "required" });
+}
+async function runToolCommand(kind, operands, options, auth) {
+    const prepared = await prepareRouterRequest(kind, operands, options);
+    const apiKey = auth.auth === "required" ? requireRouterKey(kind) : getApiKey();
+    const spinner = options.json ? undefined : ora(spinnerText(kind)).start();
+    let result;
+    try {
+        result = await routerPost({
+            operation: kind,
+            body: prepared.body,
+            apiKey,
+        });
+    }
+    catch (err) {
+        spinner?.fail("Request failed");
+        throw transportError(err.message);
+    }
+    spinner?.stop();
+    const applicationOk = result.status >= 200 && result.status < 300;
+    if (options.json) {
+        writeRawStdout(result.raw);
+    }
+    else if (applicationOk) {
+        renderHuman(kind, result.raw);
+    }
+    else {
+        printError(httpErrorMessage(result.status, result.raw));
+        if (result.raw.trim()) {
+            console.error(result.raw);
+        }
+    }
+    if (!applicationOk) {
+        throw new CliError("", EXIT_TRANSPORT);
+    }
+    if (batchHasFailure(result.raw)) {
+        process.exitCode = EXIT_PARTIAL;
+    }
+}
+function requireRouterKey(kind) {
+    const key = getApiKey();
+    if (!key) {
+        throw new CliError(`No API key found. Run "aisa login --key <key>" or set ${ENV_VAR_NAME}. ` +
+            `search and schema may be anonymous; ${kind} will not run without a key. ` +
+            `Do not invent a business result.`, EXIT_TRANSPORT);
+    }
+    return key;
+}
+function spinnerText(kind) {
+    switch (kind) {
+        case "search":
+            return "Searching published tools...";
+        case "schema":
+            return "Fetching tool schemas...";
+        case "quote":
+            return "Quoting published tools...";
+        case "call":
+            return "Calling published tools...";
+    }
+}
+/** Unmodified application body. No parse/stringify round trip. */
+export function writeRawStdout(raw) {
+    const text = raw.endsWith("\n") ? raw : raw + "\n";
+    process.stdout.write(text);
+}
+function httpErrorMessage(status, raw) {
+    const code = rawFieldString(raw, "code");
+    const message = rawFieldString(raw, "message");
+    if (code && message)
+        return `${status}: ${code}: ${message}`;
+    if (message)
+        return `${status}: ${message}`;
+    return `${status}: Router request failed`;
+}
+/**
+ * Partial batch: any failed item in a 200 envelope. Counts are small integers
+ * so a structural parse is safe; the raw body has already been written for --json.
+ */
+export function batchHasFailure(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value.error_count === "number" && value.error_count > 0)
+            return true;
+        if (Array.isArray(value.results)) {
+            return value.results.some((item) => isRecord(item) && item.successful === false);
+        }
+        if (isRecord(value.tools)) {
+            return Object.values(value.tools).some((item) => isRecord(item) && item.successful === false);
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function renderHuman(kind, raw) {
+    let value;
+    try {
+        const parsed = parseJsonKeepingNumberTokens(raw);
+        if (!isRecord(parsed)) {
+            console.log(raw);
+            return;
+        }
+        value = parsed;
+    }
+    catch {
+        console.log(raw);
+        return;
+    }
+    if (kind === "search") {
+        renderSearch(value);
+        return;
+    }
+    if (kind === "schema") {
+        renderSchema(value);
+        return;
+    }
+    renderBatch(kind, value);
+}
+function renderSearch(value) {
+    if (typeof value.search_id === "string") {
+        console.log(`\n  ${chalk.gray("search_id")} ${value.search_id}`);
+    }
+    renderPlan(value.plan);
+    const tools = Array.isArray(value.tools) ? value.tools : [];
+    if (tools.length === 0) {
+        console.log(`\n  ${chalk.yellow("No executable tools returned.")}`);
+    }
+    for (const item of tools) {
+        if (!isRecord(item))
+            continue;
+        const name = typeof item.tool === "string" ? item.tool : "(unknown tool)";
+        const summary = typeof item.summary === "string" ? item.summary : "";
+        const full = item.has_full_schema === true;
+        console.log(`\n  ${chalk.cyan.bold(name)} ${chalk.gray(full ? "full schema" : "schema incomplete")}`);
+        if (summary)
+            console.log(`    ${summary}`);
+        if (item.has_full_schema === false) {
+            console.log(chalk.gray("    Next: aisa schema " + name));
+        }
+        if (isRecord(item.price)) {
+            console.log(chalk.gray("    Price is catalog metadata — not an exact charge. Use --json for tokens."));
+        }
+    }
+    printGuidance(value.next_steps_guidance);
+    console.log();
+}
+function renderSchema(value) {
+    const tools = isRecord(value.tools) ? value.tools : {};
+    console.log();
+    for (const [name, item] of Object.entries(tools)) {
+        if (!isRecord(item))
+            continue;
+        if (item.successful === false) {
+            const err = isRecord(item.error) ? item.error : {};
+            const code = typeof err.code === "string" ? err.code : "error";
+            const message = typeof err.message === "string" ? err.message : "lookup failed";
+            console.log(`  ${chalk.red.bold(name)} failed (${code})`);
+            console.log(`    ${message}`);
+            continue;
+        }
+        console.log(`  ${chalk.cyan.bold(name)} ${chalk.green("ok")}`);
+        if (item.arguments_schema !== undefined) {
+            console.log(chalk.gray("    arguments_schema present — use --json for the contract"));
+        }
+        if (item.response_schema !== undefined) {
+            console.log(chalk.gray("    response_schema present — use --json for the contract"));
+        }
+        printStringList("    pitfalls", item.known_pitfalls);
+    }
+    printCounts(value);
+    printGuidance(value.next_steps_guidance);
+    console.log();
+}
+function renderPlan(plan) {
+    if (!isRecord(plan))
+        return;
+    if (typeof plan.plan_ref === "string") {
+        console.log(`\n  ${chalk.bold("Plan")} ${plan.plan_ref}`);
+    }
+    else {
+        console.log(`\n  ${chalk.bold("Plan")}`);
+    }
+    printStringList("    step", plan.recommended_steps);
+    printStringList("    pitfall", plan.known_pitfalls);
+}
+function renderBatch(kind, value) {
+    if (typeof value.batch_id === "string") {
+        console.log(`\n  ${chalk.gray("batch_id")} ${value.batch_id}`);
+    }
+    const results = Array.isArray(value.results) ? value.results : [];
+    for (const item of results) {
+        if (!isRecord(item))
+            continue;
+        const callId = typeof item.call_id === "string" ? item.call_id : "?";
+        const tool = typeof item.tool === "string" ? item.tool : "?";
+        const requestId = typeof item.request_id === "string" ? item.request_id : "";
+        if (item.successful === false) {
+            const err = isRecord(item.error) ? item.error : {};
+            const type = typeof err.type === "string" ? err.type : "error";
+            const message = typeof err.message === "string" ? err.message : "call failed";
+            console.log(`\n  ${chalk.red.bold(callId)} ${tool} failed (${type})`);
+            console.log(`    ${message}`);
+            if (requestId)
+                console.log(chalk.gray(`    request_id ${requestId}`));
+            continue;
+        }
+        console.log(`\n  ${chalk.green.bold(callId)} ${tool}`);
+        if (requestId)
+            console.log(chalk.gray(`    request_id ${requestId}`));
+        if (kind === "quote") {
+            renderQuoteData(item.data);
+        }
+        else {
+            const charged = numberToken(item.customer_cost_micros_usd);
+            if (charged) {
+                console.log(`    customer_cost_micros_usd ${charged} (as reported; not converted to dollars)`);
+            }
+            else {
+                console.log(chalk.gray("    customer cost not reported — not treated as zero"));
+            }
+            console.log(chalk.gray("    result data: use --json for the unmodified payload"));
+        }
+    }
+    printCounts(value);
+    printGuidance(value.next_steps_guidance);
+    if (kind === "quote") {
+        console.log(chalk.gray("\n  Quote is a price observation, not authorization to execute."));
+    }
+    console.log();
+}
+function renderQuoteData(data) {
+    if (!isRecord(data)) {
+        console.log(chalk.gray("    quote data missing — not treated as zero"));
+        return;
+    }
+    const kind = typeof data.estimate_kind === "string" ? data.estimate_kind : "unknown";
+    const mayExceed = data.may_exceed_estimate === true;
+    const estimated = numberToken(data.estimated_cost_micros_usd);
+    const max = numberToken(data.max_cost_micros_usd);
+    console.log(`    estimate_kind ${kind}${mayExceed ? " (may exceed estimate)" : ""}`);
+    if (estimated) {
+        console.log(`    estimated_cost_micros_usd ${estimated} (as reported; not an exact dollar price)`);
+    }
+    else {
+        console.log(chalk.gray("    estimated cost not reported — not treated as zero"));
+    }
+    if (max) {
+        console.log(`    max_cost_micros_usd ${max} (ceiling token, not converted)`);
+    }
+    if (kind === "estimate" || mayExceed) {
+        console.log(chalk.gray("    This figure may be exceeded; do not treat it as a firm price."));
+    }
+}
+function printCounts(value) {
+    const total = numberToken(value.total_count);
+    const ok = numberToken(value.success_count);
+    const err = numberToken(value.error_count);
+    if (total !== undefined || ok !== undefined || err !== undefined) {
+        console.log(`\n  ${ok ?? "?"} ok · ${err ?? "?"} failed · ${total ?? "?"} total`);
+    }
+}
+function printGuidance(guidance) {
+    if (!Array.isArray(guidance) || guidance.length === 0)
+        return;
+    console.log(chalk.bold(`\n  Next steps`));
+    for (const line of guidance) {
+        if (typeof line === "string")
+            console.log(`    ${projectMcpIdentifiersToCli(line)}`);
+    }
+}
+function printStringList(label, value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return;
+    for (const line of value) {
+        if (typeof line === "string")
+            console.log(`${label}: ${projectMcpIdentifiersToCli(line)}`);
+    }
+}
+function rawFieldString(raw, key) {
+    const match = raw.match(new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`));
+    return match?.[1];
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Update this copy of the CLI, whichever way it was installed.
+ *
+ * No confirmation prompt. Typing `aisa update` is the intent — asking "are
+ * you sure" after it is a speed bump, not a safeguard. What does get asked is
+ * the question the user cannot answer from here: when the install cannot be
+ * changed by this process (no write access, or a package manager whose global
+ * install this process should not guess at), the command to run is printed
+ * rather than attempted.
+ */
+export declare function updateAction(): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,92 @@
+import { VERSION } from "../constants.js";
+import { success, error, info, hint } from "../utils/display.js";
+import { runShell, runSync, QUICK_TIMEOUT_MS } from "../utils/exec.js";
+import { pickNpmChannel, npmPrefixWritable } from "./install.js";
+import { detectInstall } from "../utils/install-method.js";
+import { checkForUpdate } from "../utils/update-check.js";
+const PACKAGE = "@aisa-one/cli";
+/** The version actually on PATH — may differ from the VERSION this process
+ *  was built with if another copy shadows it, so ask the binary, not the build. */
+function installedVersion() {
+    const r = runSync("aisa", ["--version"], { timeout: QUICK_TIMEOUT_MS });
+    return r.status === 0 ? r.stdout.trim() : VERSION;
+}
+/**
+ * Update this copy of the CLI, whichever way it was installed.
+ *
+ * No confirmation prompt. Typing `aisa update` is the intent — asking "are
+ * you sure" after it is a speed bump, not a safeguard. What does get asked is
+ * the question the user cannot answer from here: when the install cannot be
+ * changed by this process (no write access, or a package manager whose global
+ * install this process should not guess at), the command to run is printed
+ * rather than attempted.
+ */
+export async function updateAction() {
+    const before = installedVersion();
+    const install = detectInstall();
+    // npx resolves the published version on every invocation, so there is
+    // nothing here to update — and installing a global would leave the user
+    // with a second copy they did not ask for and did not know about.
+    if (install.kind === "npx") {
+        info(`Current version: ${before}`);
+        success("Nothing to update — npx fetches the published version every time");
+        hint(`for a copy that stays put: npm install -g ${PACKAGE}`);
+        return;
+    }
+    // A checkout run from its own dist. Updating it means pulling, and this
+    // process has no business guessing at someone's working tree.
+    if (install.kind === "source") {
+        info(`Current version: ${before}`);
+        error("This is a working copy, not an installed package");
+        hint(`running from ${install.path} — update it with git`);
+        process.exitCode = 1;
+        return;
+    }
+    const latest = await checkForUpdate({ current: before });
+    info(`Current version: ${before}${latest ? ` — ${latest} is available` : ""}`);
+    if (!install.command) {
+        error("Could not tell how this copy was installed");
+        hint(`running from ${install.path}`);
+        hint(`if you used npm: npm install -g ${PACKAGE}@latest`);
+        process.exitCode = 1;
+        return;
+    }
+    // The registry probe and the writability check are npm's business; the
+    // other managers have their own resolution and their own global roots, and
+    // a guess about either is worse than letting the manager speak for itself.
+    let command = install.command;
+    if (install.kind === "npm") {
+        const channel = await pickNpmChannel(PACKAGE);
+        if (channel.kind === "offline") {
+            error("Could not reach the npm registry (official or mirror)");
+            hint("check your network and try again");
+            process.exitCode = 1;
+            return;
+        }
+        if (channel.kind === "mirror")
+            command += ` --registry=${channel.registry}`;
+        if (!npmPrefixWritable()) {
+            error("npm's global prefix is not writable by this user");
+            hint(`run this yourself: ${command}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    info(command);
+    const result = await runShell(command);
+    if (!result.ok) {
+        error("Update failed");
+        if (result.detail)
+            hint(result.detail);
+        hint(`you can also run it yourself: ${command}`);
+        process.exitCode = 1;
+        return;
+    }
+    const after = installedVersion();
+    if (after === before) {
+        success(`Already on the latest version (${after})`);
+    }
+    else {
+        success(`Updated ${before} → ${after}`);
+    }
+}