noslopui 0.0.1 → 0.2.0

package/dist/adapters/json-adapter.js

@@ -0,0 +1,135 @@
+// The shared shape of every agent whose MCP config is a JSON file.
+//
+// Seven of the eight agents keep their servers in a JSON object keyed by
+// server name; they differ only in where the file is, what the object is
+// called (`mcpServers`, `servers`, `mcp`), and which fields a remote server
+// takes (`url` or `serverUrl`, plus `type: "http"`, `transport: "http"` or
+// `type: "remote"`). Each adapter states those facts and nothing else; the
+// rules for editing a file we don't own live here once, in `lib/json-file.ts`
+// underneath:
+//
+//   · back up before the first write, merge, never touch another entry
+//   · keep fields on our own entry that we didn't put there
+//   · write atomically, and stop cold on a file that doesn't parse
+//   · read the entry back — several of these files have another writer
+import { existsSync } from 'node:fs';
+import { backupFile, detectIndent, readJsonFile, writeJsonFile } from '../lib/json-file.js';
+import { installSkillAt, removeSkillAt } from '../lib/skill-file.js';
+import { onPath } from '../lib/paths.js';
+/** The name the server appears under in every agent. */
+export const SERVER_NAME = 'noslopui';
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export class JsonConfigAdapter {
+    spec;
+    id;
+    label;
+    constructor(spec) {
+        this.spec = spec;
+        this.id = spec.id;
+        this.label = spec.label;
+    }
+    configPath() {
+        return this.spec.configPath();
+    }
+    skillPath() {
+        return this.spec.skillPath();
+    }
+    async detect() {
+        try {
+            if ((this.spec.detectBinaries ?? []).some(onPath))
+                return true;
+            return this.spec.detectPaths().some((p) => existsSync(p));
+        }
+        catch {
+            return false;
+        }
+    }
+    async install(entry) {
+        const path = this.configPath();
+        const config = readJsonFile(path) ?? {};
+        const backupPath = backupFile(path);
+        const servers = isObject(config[this.spec.container]) ? config[this.spec.container] : {};
+        const replacedExisting = SERVER_NAME in servers;
+        // Spread the existing entry so anything the agent (or the user) added to
+        // it that we don't know about survives the update.
+        const existing = isObject(servers[SERVER_NAME]) ? servers[SERVER_NAME] : {};
+        const existingHeaders = isObject(existing.headers) ? existing.headers : {};
+        // The other spelling of the url field would be read instead of ours by an
+        // agent that accepts both, so it goes.
+        const { url: _url, serverUrl: _serverUrl, ...rest } = existing;
+        servers[SERVER_NAME] = {
+            ...rest,
+            ...(this.spec.fixed ?? {}),
+            [this.spec.urlField]: entry.url,
+            headers: { ...existingHeaders, Authorization: `Bearer ${entry.key}` },
+        };
+        config[this.spec.container] = servers;
+        writeJsonFile(path, config, { indent: existsSync(path) ? detectIndent(path) : 2 });
+        // Read back: a successful write is not the same as a config that says
+        // what we think it says, when something else may rewrite the file.
+        const after = await this.status();
+        if (!after.installed || after.url !== entry.url || !after.hasKey) {
+            throw new Error(`The entry was written to ${path} but reading it back didn't show it.${this.spec.readBackHint ? ` ${this.spec.readBackHint}` : ''}`);
+        }
+        return { configPath: path, backupPath, method: 'config-file', replacedExisting };
+    }
+    async status() {
+        const path = this.configPath();
+        const config = readJsonFile(path);
+        const servers = config && isObject(config[this.spec.container]) ? config[this.spec.container] : null;
+        const entry = servers && isObject(servers[SERVER_NAME]) ? servers[SERVER_NAME] : null;
+        if (!entry)
+            return { installed: false, configPath: path, url: null, hasKey: false };
+        const raw = entry[this.spec.urlField];
+        const url = typeof raw === 'string' ? raw : null;
+        const headers = isObject(entry.headers) ? entry.headers : {};
+        const auth = typeof headers.Authorization === 'string' ? headers.Authorization : '';
+        const hasKey = /^Bearer\s+\S+/i.test(auth);
+        let problem;
+        if (!url)
+            problem = `The entry has no "${this.spec.urlField}".`;
+        else if (!hasKey)
+            problem = 'The entry has no Authorization header, so the agent will be asked to sign in.';
+        else {
+            for (const [field, value] of Object.entries(this.spec.fixed ?? {})) {
+                if (entry[field] !== value) {
+                    problem = `The entry's ${field} is "${String(entry[field])}", expected "${String(value)}".`;
+                    break;
+                }
+            }
+        }
+        return { installed: true, configPath: path, url, hasKey, ...(problem ? { problem } : {}) };
+    }
+    async configuredKey() {
+        try {
+            const config = readJsonFile(this.configPath());
+            const servers = config && isObject(config[this.spec.container]) ? config[this.spec.container] : null;
+            const entry = servers && isObject(servers[SERVER_NAME]) ? servers[SERVER_NAME] : null;
+            const headers = entry && isObject(entry.headers) ? entry.headers : {};
+            const auth = typeof headers.Authorization === 'string' ? headers.Authorization : '';
+            return auth.match(/^Bearer\s+(\S+)$/i)?.[1] ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async uninstall() {
+        const path = this.configPath();
+        const config = readJsonFile(path);
+        const servers = config && isObject(config[this.spec.container]) ? config[this.spec.container] : null;
+        if (!config || !servers || !(SERVER_NAME in servers))
+            return false;
+        backupFile(path);
+        delete servers[SERVER_NAME];
+        writeJsonFile(path, config, { indent: detectIndent(path) });
+        return true;
+    }
+    async installSkill(markdown) {
+        const path = this.skillPath();
+        return path ? installSkillAt(path, markdown) : null;
+    }
+    async removeSkill() {
+        const path = this.skillPath();
+        return path ? removeSkillAt(path) : false;
+    }
+}

package/dist/adapters/json-agents.js

@@ -0,0 +1,88 @@
+// Every agent whose MCP config is a JSON file, apart from Claude Code (which
+// has its own module for its history). Each entry is only facts, and each fact
+// is from that vendor's own documentation, checked 2026-09-21:
+//
+//   Cursor       cursor.com/docs/context/mcp, …/context/skills
+//   VS Code      code.visualstudio.com/docs/copilot/customization/mcp-servers, …/agent-skills
+//   Devin        docs.devin.ai/cli/extensibility/mcp/configuration, …/skills
+//   Windsurf     docs.devin.ai/desktop/cascade/mcp (the legacy Cascade agent)
+//   OpenCode     opencode.ai/docs/config, …/mcp-servers, …/skills
+//   Antigravity  antigravity.google/docs/mcp
+//
+// Windsurf shipped as Devin Desktop in June 2026 and now has two agents with
+// two config files: Devin Local (the default for new tabs, and the Devin CLI)
+// reads the Devin CLI's config; the legacy Cascade agent still reads
+// ~/.codeium/windsurf/mcp_config.json. They're two adapters, so each is
+// detected, written and checked on its own. Both read skills from
+// ~/.codeium/windsurf/skills, so they share one copy.
+import { join } from 'node:path';
+import { JsonConfigAdapter } from './json-adapter.js';
+import { appData, home, sharedSkillPath, vscodeUserDir, xdgConfig } from '../lib/paths.js';
+const devinConfigDir = () => (process.platform === 'win32' ? join(appData(), 'devin') : join(xdgConfig(), 'devin'));
+const windsurfSkillPath = () => join(home(), '.codeium', 'windsurf', 'skills', 'noslopui', 'SKILL.md');
+export const cursor = () => new JsonConfigAdapter({
+    id: 'cursor',
+    label: 'Cursor',
+    configPath: () => join(home(), '.cursor', 'mcp.json'),
+    container: 'mcpServers',
+    urlField: 'url',
+    detectPaths: () => [join(home(), '.cursor')],
+    detectBinaries: ['cursor'],
+    skillPath: sharedSkillPath,
+});
+export const vscode = () => new JsonConfigAdapter({
+    id: 'vscode',
+    label: 'VS Code',
+    configPath: () => join(vscodeUserDir(), 'mcp.json'),
+    container: 'servers',
+    urlField: 'url',
+    fixed: { type: 'http' },
+    detectPaths: () => [vscodeUserDir()],
+    detectBinaries: ['code'],
+    skillPath: sharedSkillPath,
+});
+export const devin = () => new JsonConfigAdapter({
+    id: 'devin',
+    label: 'Devin Desktop',
+    configPath: () => join(devinConfigDir(), 'mcp_config.json'),
+    container: 'mcpServers',
+    urlField: 'url',
+    fixed: { transport: 'http' },
+    detectPaths: () => [devinConfigDir()],
+    detectBinaries: ['devin'],
+    skillPath: windsurfSkillPath,
+});
+export const windsurf = () => new JsonConfigAdapter({
+    id: 'windsurf',
+    label: 'Windsurf (Cascade)',
+    configPath: () => join(home(), '.codeium', 'windsurf', 'mcp_config.json'),
+    container: 'mcpServers',
+    urlField: 'serverUrl',
+    detectPaths: () => [join(home(), '.codeium', 'windsurf')],
+    detectBinaries: ['windsurf'],
+    skillPath: windsurfSkillPath,
+});
+export const opencode = () => new JsonConfigAdapter({
+    id: 'opencode',
+    label: 'OpenCode',
+    // OpenCode also reads opencode.jsonc. We only ever write the .json file:
+    // a .jsonc may carry comments that a JSON round trip would delete, and
+    // the reader refuses a file it can't parse rather than rewrite it.
+    configPath: () => join(xdgConfig(), 'opencode', 'opencode.json'),
+    container: 'mcp',
+    urlField: 'url',
+    fixed: { type: 'remote', enabled: true },
+    detectPaths: () => [join(xdgConfig(), 'opencode')],
+    detectBinaries: ['opencode'],
+    skillPath: sharedSkillPath,
+});
+export const antigravity = () => new JsonConfigAdapter({
+    id: 'antigravity',
+    label: 'Antigravity',
+    configPath: () => join(home(), '.gemini', 'config', 'mcp_config.json'),
+    container: 'mcpServers',
+    urlField: 'serverUrl',
+    detectPaths: () => [join(home(), '.gemini', 'config'), join(home(), '.gemini', 'antigravity')],
+    detectBinaries: ['antigravity'],
+    skillPath: () => join(home(), '.gemini', 'config', 'skills', 'noslopui', 'SKILL.md'),
+});

package/dist/adapters/types.js

@@ -0,0 +1,8 @@
+// The shape every agent adapter fills in.
+//
+// Adding an agent is meant to be this file's worth of work and nothing else:
+// the facts about its config (most agents are one entry in json-agents.ts),
+// one entry in the registry, the same id in the server's CLI_AGENTS, and a
+// fixture test. The interesting part of supporting a new agent is finding out
+// from its own docs where it keeps things, not writing code.
+export {};

package/dist/commands/account.js

@@ -0,0 +1,49 @@
+// `noslopui whoami` and `noslopui logout` — the CLI's own session.
+import { origin, whoami as fetchAccount } from '../lib/api.js';
+import { clearSession, readSession, sessionPath } from '../lib/session.js';
+import { color, hint, ok, say, warn } from '../lib/ui.js';
+export async function whoami(options) {
+    const session = readSession();
+    if (!session) {
+        if (options.json)
+            say(JSON.stringify({ signedIn: false }));
+        else {
+            say();
+            warn('Not signed in.');
+            hint('Run "npx noslopui login".');
+            say();
+        }
+        return 1;
+    }
+    const account = await fetchAccount(session.key);
+    if (options.json) {
+        say(JSON.stringify({ signedIn: true, ...account }, null, 2));
+        return 0;
+    }
+    const plan = account.plan === 'paid'
+        ? 'paid plan'
+        : account.plan === 'trial'
+            ? account.trialEndsAt
+                ? `free trial, ends ${new Date(account.trialEndsAt).toLocaleDateString()}`
+                : 'free trial, not started yet — the first unlock starts it'
+            : 'free — search and collections; code and DESIGN.md files need a plan';
+    say();
+    ok(`${color.bold(account.email ?? 'Signed in')} · ${plan}`);
+    hint(session.savedAt === 'env' ? 'key from NOSLOPUI_API_KEY' : `key saved in ${sessionPath()}`);
+    say();
+    return 0;
+}
+export async function logout() {
+    say();
+    if (clearSession()) {
+        ok('Signed out on this machine.');
+        hint(`The key still exists on your account — revoke it at ${origin()}/account?tab=mcp if this machine shouldn't have it.`);
+    }
+    else {
+        warn('Not signed in, so nothing to do.');
+    }
+    if (process.env.NOSLOPUI_API_KEY)
+        hint('NOSLOPUI_API_KEY is still set in this shell.');
+    say();
+    return 0;
+}

package/dist/commands/catalog.js

@@ -0,0 +1,191 @@
+// The catalog from the terminal: search, get, prompt, design-system,
+// design-systems, collections, collection.
+//
+// Every command is one call to the MCP server's own tools with the CLI's key,
+// so the terminal and an agent always see the same thing, and every gate —
+// plan, trial, fair use — stays on the server where it belongs.
+//
+// Output rule: the thing asked for goes to stdout, everything about it goes to
+// stderr. `npx noslopui get hero-aurora > Hero.tsx` has to produce a file with
+// nothing in it but the component.
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { callTool } from '../lib/api.js';
+import { readSession } from '../lib/session.js';
+import { color } from '../lib/ui.js';
+const out = (s = '') => process.stdout.write(`${s}\n`);
+const note = (s = '') => process.stderr.write(`${s}\n`);
+function requireKey() {
+    const session = readSession();
+    if (!session)
+        throw new Error('Not signed in. Run "npx noslopui login" first — it takes one approval in the browser.');
+    return session.key;
+}
+function requireArg(options, what) {
+    const value = options.args.join(' ').trim();
+    if (!value)
+        throw new Error(`Say which ${what}.`);
+    return value;
+}
+/** A tool error is the server telling the user something; print it as-is and fail. */
+function check(result) {
+    if (result.isError)
+        throw new Error(result.text);
+    return result;
+}
+/** Notices the server attaches to a result (the trial just started, and so on). */
+function notices(data) {
+    if (typeof data?.trial === 'string')
+        note(color.yellow(`! ${data.trial}`));
+}
+function writeOut(path, text, force) {
+    const target = resolve(path);
+    if (existsSync(target) && !force)
+        throw new Error(`${target} already exists. Pass --force to overwrite it.`);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, text.endsWith('\n') ? text : `${text}\n`, 'utf8');
+    note(`${color.green('✔')} wrote ${target}`);
+}
+const truncate = (s, n) => (s && s.length > n ? `${s.slice(0, n - 1)}…` : s ?? '');
+export async function search(options) {
+    const key = requireKey();
+    const r = check(await callTool(key, 'search_components', {
+        ...(options.args.length ? { query: options.args.join(' ') } : {}),
+        ...(options.tags.length ? { tags: options.tags } : {}),
+        ...(options.framework ? { framework: options.framework } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+    }));
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    const results = r.data?.results ?? [];
+    if (!results.length) {
+        note('Nothing matched. Try fewer words, or no tags.');
+        return 1;
+    }
+    for (const item of results) {
+        out(`${color.bold(item.name)}  ${color.dim(item.id)}`);
+        if (item.description)
+            out(`  ${truncate(item.description, 110)}`);
+        out(`  ${color.cyan(item.url)}`);
+        out();
+    }
+    note(color.dim(`Get one with "npx noslopui get <id>".`));
+    return 0;
+}
+export async function designSystems(options) {
+    const key = requireKey();
+    const r = check(await callTool(key, 'search_design_systems', {
+        ...(options.args.length ? { query: options.args.join(' ') } : {}),
+        ...(options.tags.length ? { tags: options.tags } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+    }));
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    const results = r.data?.results ?? [];
+    if (!results.length) {
+        note('Nothing matched.');
+        return 1;
+    }
+    for (const ds of results) {
+        const inspired = ds.inspiredBy ? color.dim(` · inspired by ${ds.inspiredBy}`) : '';
+        out(`${color.bold(ds.name)}  ${color.dim(ds.id)}${inspired}`);
+        if (ds.description)
+            out(`  ${truncate(ds.description, 110)}`);
+        if (ds.tags?.length)
+            out(`  ${color.dim(ds.tags.join(' · '))}`);
+        out(`  ${color.cyan(ds.previewUrl)}`);
+        out();
+    }
+    note(color.dim(`Get its DESIGN.md with "npx noslopui design-system <id> --write DESIGN.md".`));
+    return 0;
+}
+export async function get(options) {
+    const key = requireKey();
+    const id = requireArg(options, 'component (its id, from "npx noslopui search")');
+    const r = check(await callTool(key, 'get_component_code', { id }));
+    notices(r.data);
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    const snippets = r.data?.snippets ?? [];
+    if (!snippets.length)
+        throw new Error('This item has no published code.');
+    const chosen = options.format ? snippets.filter((s) => s.language === options.format) : snippets;
+    if (!chosen.length) {
+        throw new Error(`No ${options.format} version. Available: ${snippets.map((s) => s.language).join(', ')}.`);
+    }
+    if (options.write) {
+        if (chosen.length > 1)
+            throw new Error(`Several formats (${chosen.map((s) => s.language).join(', ')}) — pick one with --format.`);
+        writeOut(options.write, chosen[0].code, options.force);
+        return 0;
+    }
+    if (chosen.length === 1) {
+        out(chosen[0].code);
+        return 0;
+    }
+    for (const s of chosen) {
+        note(color.dim(`── ${s.language} ──`));
+        out(s.code);
+    }
+    return 0;
+}
+export async function prompt(options) {
+    const key = requireKey();
+    const id = requireArg(options, 'component');
+    const r = check(await callTool(key, 'get_component_prompt', { id }));
+    notices(r.data);
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    if (options.write)
+        writeOut(options.write, r.data?.promptText ?? '', options.force);
+    else
+        out(r.data?.promptText ?? '');
+    return 0;
+}
+export async function designSystem(options) {
+    const key = requireKey();
+    const id = requireArg(options, 'design system (its id, from "npx noslopui design-systems")');
+    const r = check(await callTool(key, 'get_design_system_file', { id }));
+    notices(r.data);
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    if (options.write)
+        writeOut(options.write, r.data?.designMd ?? '', options.force);
+    else
+        out(r.data?.designMd ?? '');
+    return 0;
+}
+export async function collections(options) {
+    const key = requireKey();
+    const r = check(await callTool(key, 'list_collections'));
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    const list = r.data?.collections ?? [];
+    if (!list.length) {
+        note('No collections yet. Save items on noslopui.com to make one.');
+        return 0;
+    }
+    for (const c of list)
+        out(`${color.bold(c.name)}  ${color.dim(`${c.itemCount} ${c.itemCount === 1 ? 'item' : 'items'} · ${c.id}`)}`);
+    return 0;
+}
+export async function collection(options) {
+    const key = requireKey();
+    const which = requireArg(options, 'collection (a name or an id)');
+    // Ids are opaque; try the name first, since that's what people type.
+    let r = await callTool(key, 'get_collection', { name: which });
+    if (r.isError)
+        r = await callTool(key, 'get_collection', { listId: which });
+    check(r);
+    if (options.json)
+        return out(JSON.stringify(r.data, null, 2)), 0;
+    out(color.bold(r.data?.collection ?? which));
+    const systems = r.data?.designSystems ?? [];
+    if (systems.length)
+        out(`${color.dim('design system:')} ${systems.map((d) => `${d.name} (${d.id})`).join(', ')}`);
+    out();
+    for (const item of r.data?.items ?? []) {
+        out(`${item.name}  ${color.dim(`${item.kind === 'design_systems' ? 'design system' : 'block'} · ${item.id}`)}`);
+    }
+    return 0;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,129 @@
+// `noslopui doctor` — what's set up, what's wrong, and what to do about it.
+//
+// The rule for every line: if something is broken, say the one thing that
+// fixes it. A diagnostic that only reports a state leaves the user exactly
+// where they started.
+import { existsSync, readFileSync } from 'node:fs';
+import { checkServer, mcpUrl, origin, whoami } from '../lib/api.js';
+import { ADAPTERS } from '../adapters/index.js';
+import { ConfigUnreadableError } from '../lib/json-file.js';
+import { readSession } from '../lib/session.js';
+import { color, fail, hint, ok, say, warn } from '../lib/ui.js';
+export async function doctor() {
+    let problems = 0;
+    say();
+    say(`${color.bold('noslopUI doctor')} ${color.dim(`— ${origin()}`)}`);
+    say();
+    say(color.bold('Server'));
+    const reach = await checkServer();
+    if (reach.reachable)
+        ok(`${mcpUrl()} — ${reach.detail}`);
+    else {
+        fail(reach.detail);
+        hint('If you are behind a proxy or VPN, that is the usual cause.');
+        problems++;
+    }
+    say();
+    say(color.bold('This CLI'));
+    const session = readSession();
+    if (!session) {
+        say(`${color.dim('–')} ${color.dim('not signed in (only needed for "noslopui search" and "get"; run "npx noslopui login")')}`);
+    }
+    else {
+        try {
+            const account = await whoami(session.key);
+            ok(`Signed in as ${account.email ?? 'your account'} (${account.plan})`);
+        }
+        catch (err) {
+            fail(err.message);
+            hint('Run "npx noslopui login" to sign in again.');
+            problems++;
+        }
+    }
+    let anyAgent = false;
+    for (const adapter of ADAPTERS) {
+        if (!(await adapter.detect()))
+            continue;
+        anyAgent = true;
+        say();
+        say(color.bold(adapter.label));
+        let status;
+        try {
+            status = await adapter.status();
+        }
+        catch (err) {
+            if (err instanceof ConfigUnreadableError) {
+                fail(err.message);
+                hint('Fix that file by hand — this tool will not overwrite a config it cannot read.');
+                problems++;
+                continue;
+            }
+            throw err;
+        }
+        if (!status.installed) {
+            warn('noslopUI is not set up here.');
+            hint(`Run "npx noslopui init --agent ${adapter.id}".`);
+            problems++;
+        }
+        else {
+            ok(`Configured in ${status.configPath}`);
+            if (status.url !== mcpUrl()) {
+                warn(`The configured url is ${status.url}, but this CLI expects ${mcpUrl()}.`);
+                hint(`Run "npx noslopui init --agent ${adapter.id}" to update it.`);
+                problems++;
+            }
+            if (status.problem) {
+                warn(status.problem);
+                hint(`Run "npx noslopui init --agent ${adapter.id}" to repair the entry.`);
+                problems++;
+            }
+            const key = await adapter.configuredKey();
+            if (key) {
+                const probe = await checkServer(key);
+                if (probe.keyState === 'ok') {
+                    ok('The configured key works.');
+                }
+                else if (probe.keyState === 'rejected') {
+                    fail(probe.keyDetail ?? 'The configured key was refused.');
+                    hint(`Run "npx noslopui login --agent ${adapter.id}" for a fresh key.`);
+                    problems++;
+                }
+            }
+        }
+        const skillPath = adapter.skillPath();
+        if (!skillPath) {
+            say(`${color.dim('–')} ${color.dim('no skills folder; the rules reach it through the server')}`);
+        }
+        else if (existsSync(skillPath)) {
+            let current = '';
+            try {
+                current = readFileSync(skillPath, 'utf8');
+            }
+            catch {
+                current = '';
+            }
+            if (current.includes('noslopui'))
+                ok(`Skill installed at ${skillPath}`);
+            else
+                warn(`${skillPath} exists but doesn't look like the noslopUI skill.`);
+        }
+        else {
+            warn('The skill is not installed.');
+            hint('Optional, but it is what makes "build me a website" use noslopUI at all. Run "npx noslopui update".');
+        }
+    }
+    if (!anyAgent) {
+        say();
+        warn(`None of the agents this CLI sets up were found (${ADAPTERS.map((a) => a.label).join(', ')}).`);
+        hint(`Any other MCP client can be connected by hand: ${origin()}/mcp`);
+    }
+    say();
+    if (problems === 0) {
+        ok('Everything checks out.');
+        say();
+        return 0;
+    }
+    fail(`${problems} ${problems === 1 ? 'problem' : 'problems'} found.`);
+    say();
+    return 1;
+}