noslopui 0.1.0 → 0.3.0

package/dist/commands/skill.js

@@ -0,0 +1,42 @@
+// `noslopui skill` — install only the skill, for someone who connected an
+// agent by hand (a connector sign-in, or a config they wrote). It never
+// touches an agent's MCP config, so a sign-in stays a sign-in.
+import { fetchSkill } from '../lib/api.js';
+import { ADAPTERS, adapterById, detectAdapters } from '../adapters/index.js';
+import { hint, ok, say, warn } from '../lib/ui.js';
+export async function skill(options) {
+    say();
+    let targets;
+    if (options.agents?.length) {
+        targets = options.agents.map((id) => {
+            const a = adapterById(id);
+            if (!a)
+                throw new Error(`Unknown agent "${id}". Supported: ${ADAPTERS.map((x) => x.id).join(', ')}.`);
+            return a;
+        });
+    }
+    else {
+        targets = await detectAdapters();
+        if (!targets.length)
+            throw new Error(`No supported agent found. Pass one with --agent: ${ADAPTERS.map((a) => a.id).join(', ')}.`);
+    }
+    const download = await fetchSkill();
+    if (download.source === 'bundled')
+        warn('Using the copy in this package — the site was unreachable, so it may be behind.');
+    const written = new Map();
+    for (const adapter of targets) {
+        const path = adapter.skillPath();
+        if (!path) {
+            ok(`${adapter.label}: no skills folder; the rules reach it through the server`);
+            continue;
+        }
+        if (!written.has(path))
+            written.set(path, (await adapter.installSkill(download.markdown))?.changed ?? false);
+        ok(`${adapter.label}: skill ${written.get(path) ? 'installed' : 'already current'}`);
+        hint(path);
+    }
+    say();
+    say('Restart your agent to pick it up.');
+    say();
+    return 0;
+}

package/dist/commands/update.js

@@ -3,7 +3,8 @@
 // In practice that means the skill: it's served from noslopui.com and changes
 // as the workflow improves, while the config entry only changes if the server
 // URL does. Nothing here needs a sign-in, so an expired trial or a revoked key
-// doesn't block it.
+// doesn't block it. Several agents share one skills folder, so each folder is
+// written once.
 import { fetchSkill, mcpUrl } from '../lib/api.js';
 import { ADAPTERS } from '../adapters/index.js';
 import { color, hint, ok, say, warn } from '../lib/ui.js';
@@ -11,6 +12,7 @@ export async function update() {
     say();
     let touched = false;
     let markdown = null;
+    const written = new Map();
     for (const adapter of ADAPTERS) {
         if (!(await adapter.detect()))
             continue;
@@ -21,22 +23,26 @@ export async function update() {
         }
         if (status.url !== mcpUrl()) {
             warn(`${adapter.label}: configured for ${status.url}, not ${mcpUrl()}.`);
-            hint('Run "npx noslopui init" to move it — that needs a key, so it is not done here.');
+            hint(`Run "npx noslopui init --agent ${adapter.id}" to move it — that needs a key, so it is not done here.`);
         }
-        markdown ??= (await fetchSkill()).markdown;
-        const skill = await adapter.installSkill(markdown);
-        if (skill.changed) {
-            ok(`${adapter.label}: skill updated`);
-            hint(skill.path);
-            touched = true;
+        const path = adapter.skillPath();
+        if (!path) {
+            ok(`${adapter.label}: no skills folder; the rules reach it through the server`);
+            continue;
         }
-        else {
-            ok(`${adapter.label}: skill already current`);
+        if (!written.has(path)) {
+            markdown ??= (await fetchSkill()).markdown;
+            const skill = await adapter.installSkill(markdown);
+            written.set(path, skill?.changed ?? false);
+            if (skill?.changed)
+                touched = true;
         }
+        ok(`${adapter.label}: skill ${written.get(path) ? 'updated' : 'already current'}`);
+        hint(path);
     }
     say();
     if (touched)
-        say(`Restart your agent to pick up the new workflow.`);
+        say('Restart your agents to pick up the new workflow.');
     say();
     return 0;
 }

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-// noslopui — connect a coding agent to noslopUI.
+// noslopui — connect a coding agent to noslopUI, and use the catalog from the
+// terminal.
 //
 // Argument parsing is by hand and stays that way: a tool people run with
 // `npx` should download in one tick, and a CLI-argument library is a
@@ -9,6 +10,10 @@ import { doctor } from './commands/doctor.js';
 import { remove } from './commands/remove.js';
 import { update } from './commands/update.js';
 import { login } from './commands/login.js';
+import { logout, whoami } from './commands/account.js';
+import { skill } from './commands/skill.js';
+import * as catalog from './commands/catalog.js';
+import { ADAPTERS } from './adapters/index.js';
 import { color, fail, say } from './lib/ui.js';
 import { origin } from './lib/api.js';
 import { CLI_VERSION as VERSION } from './lib/version.js';
@@ -19,52 +24,96 @@ ${color.bold('noslopui')} — hand-crafted UI components and design systems, in
 ${color.bold('Usage')}
   npx noslopui <command> [options]
 
-${color.bold('Commands')}
-  init        Set up an agent: sign in, add the MCP server, install the skill
-  doctor      Check what is set up and what is wrong with it
-  login       Get a fresh key for an agent that is already set up
-  update      Re-download the skill for agents that are set up
-  remove      Take the noslopUI server back out (never touches other servers)
+${color.bold('Set up')}
+  init                   Set up your agents: one sign-in, then the MCP server and the skill
+  doctor                 Check what is set up and what is wrong with it
+  update                 Re-download the skill for agents that are set up
+  skill                  Install only the skill (for an agent you connected by hand)
+  remove                 Take the noslopUI server back out (never touches other servers)
+
+${color.bold('Account')}
+  login                  Sign this CLI in (for search and get); --agent <id> re-keys an agent
+  whoami                 Show the account and plan this CLI is signed in to
+  logout                 Forget this CLI's sign-in
+
+${color.bold('Catalog')}
+  search <query>         Search blocks and effects          --section ui-blocks|motion-lab, --tag <facet:value>, --limit
+  get <id>               Print a component's code            --format tsx|html|vue, --write <file>
+  prompt <id>            Print a component's AI-prompt version
+  design-systems [query] Search design systems               --tag theme:dark …
+  design-system <id>     Print a design system's DESIGN.md   --write DESIGN.md
+  collections            List your saved collections
+  collection <name|id>   Show one collection
 
 ${color.bold('Options')}
-  --agent <id>     Set up a specific agent instead of detecting (claude-code)
+  --agent <id>     Only this agent (repeatable): ${ADAPTERS.map((a) => a.id).join(', ')}
   --no-skill       Do not install the skill (init)
   --no-browser     Do not open a browser; print the URL instead (init, login)
   --skill          Also remove the skill (remove)
   --key <key>      Use a key you already have instead of signing in (init, login)
+  --json           Machine-readable output (catalog commands, whoami)
+  --force          Overwrite the file --write points at
   -y, --yes        Take the default answer for every question
   -h, --help       Show this
   -v, --version    Show the version
 
-${color.dim(`Server: ${origin()} · set NOSLOPUI_ORIGIN to point somewhere else.`)}
+${color.dim(`Server: ${origin()} · NOSLOPUI_ORIGIN points somewhere else · NOSLOPUI_API_KEY signs in without a saved login.`)}
 `);
 }
 function parse(argv) {
-    const parsed = { command: '', agents: [], skill: null, yes: false, browser: true, help: false, version: false };
+    const parsed = { command: '', args: [], agents: [], tags: [], skill: null, yes: false, browser: true, help: false, version: false, json: false, force: false };
+    const value = (i, name) => {
+        const v = argv[i];
+        if (v === undefined || v.startsWith('-'))
+            throw new Error(`${name} needs a value.`);
+        return v;
+    };
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
-        if (arg === '--help' || arg === '-h')
+        const [flag, inline] = arg.startsWith('--') && arg.includes('=') ? [arg.slice(0, arg.indexOf('=')), arg.slice(arg.indexOf('=') + 1)] : [arg, undefined];
+        const take = () => inline ?? value(++i, flag);
+        if (flag === '--help' || flag === '-h')
             parsed.help = true;
-        else if (arg === '--version' || arg === '-v')
+        else if (flag === '--version' || flag === '-v')
             parsed.version = true;
-        else if (arg === '--yes' || arg === '-y')
+        else if (flag === '--yes' || flag === '-y')
             parsed.yes = true;
-        else if (arg === '--no-skill')
+        else if (flag === '--no-skill')
             parsed.skill = false;
-        else if (arg === '--no-browser')
+        else if (flag === '--no-browser')
             parsed.browser = false;
-        else if (arg === '--skill')
+        else if (flag === '--skill')
             parsed.skill = true;
-        else if (arg === '--agent')
-            parsed.agents.push(String(argv[++i] ?? ''));
-        else if (arg.startsWith('--agent='))
-            parsed.agents.push(arg.slice('--agent='.length));
-        else if (arg === '--key')
-            parsed.key = String(argv[++i] ?? '');
-        else if (arg.startsWith('--key='))
-            parsed.key = arg.slice('--key='.length);
-        else if (!arg.startsWith('-') && !parsed.command)
-            parsed.command = arg;
+        else if (flag === '--json')
+            parsed.json = true;
+        else if (flag === '--force')
+            parsed.force = true;
+        else if (flag === '--agent')
+            parsed.agents.push(take());
+        else if (flag === '--tag')
+            parsed.tags.push(take());
+        else if (flag === '--key')
+            parsed.key = take();
+        else if (flag === '--format')
+            parsed.format = take();
+        else if (flag === '--framework')
+            parsed.framework = take();
+        else if (flag === '--section')
+            parsed.section = take();
+        else if (flag === '--write' || flag === '-o')
+            parsed.write = take();
+        else if (flag === '--limit') {
+            const n = Number(take());
+            if (!Number.isInteger(n) || n < 1)
+                throw new Error('--limit needs a whole number.');
+            parsed.limit = n;
+        }
+        else if (!arg.startsWith('-')) {
+            if (!parsed.command)
+                parsed.command = arg;
+            else
+                parsed.args.push(arg);
+        }
         else
             throw new Error(`Unknown option "${arg}". Run "npx noslopui --help".`);
     }
@@ -81,6 +130,17 @@ async function main() {
         usage();
         return args.command ? 0 : 1;
     }
+    const catalogOptions = {
+        args: args.args,
+        json: args.json,
+        tags: args.tags,
+        force: args.force,
+        ...(args.limit ? { limit: args.limit } : {}),
+        ...(args.format ? { format: args.format } : {}),
+        ...(args.framework ? { framework: args.framework } : {}),
+        ...(args.section ? { section: args.section } : {}),
+        ...(args.write ? { write: args.write } : {}),
+    };
     switch (args.command) {
         case 'init':
             return init({ agents: args.agents, skill: args.skill !== false, yes: args.yes, browser: args.browser, ...(args.key ? { key: args.key } : {}) });
@@ -88,10 +148,30 @@ async function main() {
             return doctor();
         case 'login':
             return login({ agents: args.agents, yes: args.yes, browser: args.browser, ...(args.key ? { key: args.key } : {}) });
+        case 'logout':
+            return logout();
+        case 'whoami':
+            return whoami({ json: args.json });
         case 'update':
             return update();
+        case 'skill':
+            return skill({ agents: args.agents });
         case 'remove':
-            return remove({ yes: args.yes, skill: args.skill === true });
+            return remove({ yes: args.yes, skill: args.skill === true, agents: args.agents });
+        case 'search':
+            return catalog.search(catalogOptions);
+        case 'get':
+            return catalog.get(catalogOptions);
+        case 'prompt':
+            return catalog.prompt(catalogOptions);
+        case 'design-systems':
+            return catalog.designSystems(catalogOptions);
+        case 'design-system':
+            return catalog.designSystem(catalogOptions);
+        case 'collections':
+            return catalog.collections(catalogOptions);
+        case 'collection':
+            return catalog.collection(catalogOptions);
         default:
             fail(`Unknown command "${args.command}".`);
             usage();
@@ -108,8 +188,8 @@ main()
     process.exitCode = code;
 })
     .catch((err) => {
-    say();
+    process.stderr.write('\n');
     fail(explain(err));
-    say();
+    process.stderr.write('\n');
     process.exitCode = 1;
 });

package/dist/lib/api.js

@@ -76,19 +76,28 @@ export async function waitForApproval(started, onTick) {
     }
     throw new ApiError('The code expired before it was approved. Run the command again to get a new one.');
 }
+const MCP_HEADERS = {
+    'content-type': 'application/json',
+    accept: 'application/json, text/event-stream',
+    'mcp-protocol-version': '2025-06-18',
+    'user-agent': USER_AGENT,
+};
+/** The last JSON-RPC message in a reply, whether it came as plain JSON or SSE-framed. */
+function rpcBody(text) {
+    const line = text.split(/\r?\n/).filter((l) => l.startsWith('data: ')).pop();
+    return JSON.parse(line ? line.slice(6) : text);
+}
 /**
  * `doctor`'s probe: can we reach the MCP server, and does this key still work?
- * Uses list_collections because it's the one gated tool that costs the account
- * nothing — no trial clock, no fair-use count.
+ *
+ * Every MCP call needs a key or a sign-in, so without one the right answer is
+ * our own 401 pointing at the OAuth metadata — that's "reachable", and a
+ * challenge page or a proxy error is not. With a key it calls list_collections,
+ * the one tool that costs the account nothing: no trial clock, no fair-use count.
  */
 export async function checkServer(key) {
     let res;
-    const headers = {
-        'content-type': 'application/json',
-        accept: 'application/json, text/event-stream',
-        'mcp-protocol-version': '2025-06-18',
-        'user-agent': USER_AGENT,
-    };
+    const headers = { ...MCP_HEADERS };
     if (key)
         headers.authorization = `Bearer ${key}`;
     try {
@@ -106,28 +115,96 @@ export async function checkServer(key) {
     catch {
         return { reachable: false, detail: `Could not reach ${mcpUrl()}.` };
     }
+    const text = await res.text();
+    if (res.status === 401) {
+        const ours = /resource_metadata=/.test(res.headers.get('www-authenticate') ?? '');
+        if (!ours)
+            return { reachable: false, detail: `${mcpUrl()} answered 401, but not in the way noslopUI does — something in between is answering.` };
+        if (!key)
+            return { reachable: true, detail: 'Server reachable, and asking for sign-in as it should.' };
+        let message = 'The configured key was refused.';
+        try {
+            message = rpcBody(text)?.error?.message ?? message;
+        }
+        catch { }
+        return { reachable: true, detail: 'Server reachable.', keyState: 'rejected', keyDetail: message.split('. ')[0] };
+    }
     if (!res.ok)
         return { reachable: false, detail: `${mcpUrl()} answered HTTP ${res.status}.` };
-    const text = await res.text();
-    const line = text.split(/\r?\n/).filter((l) => l.startsWith('data: ')).pop();
-    let json = null;
+    let json;
     try {
-        json = JSON.parse(line ? line.slice(6) : text);
+        json = rpcBody(text);
     }
     catch {
         return { reachable: false, detail: 'The server answered with something unreadable.' };
     }
     if (!key)
         return { reachable: true, detail: `${(json?.result?.tools ?? []).length} tools available.` };
-    const isError = json?.result?.isError === true;
-    const body = json?.result?.content?.[0]?.text ?? '';
-    if (isError) {
+    if (json?.result?.isError === true) {
         // The server writes these for an agent to relay; they're already the right
         // words for a person, so pass them through rather than inventing our own.
+        const body = json?.result?.content?.[0]?.text ?? '';
         return { reachable: true, detail: 'Server reachable.', keyState: 'rejected', keyDetail: body.split('. ')[0] };
     }
     return { reachable: true, detail: 'Server reachable.', keyState: 'ok', keyDetail: 'Key accepted.' };
 }
+/**
+ * One MCP tool call — what the terminal commands are built on, so the CLI and
+ * an agent can never see different things, and every gate (plan, trial,
+ * fair use) is the server's.
+ */
+export async function callTool(key, name, args = {}) {
+    let res;
+    try {
+        res = await fetch(mcpUrl(), {
+            method: 'POST',
+            headers: { ...MCP_HEADERS, authorization: `Bearer ${key}` },
+            body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name, arguments: args } }),
+        });
+    }
+    catch {
+        throw new ApiError(`Could not reach ${origin()}. Check your connection, then run the command again.`);
+    }
+    const text = await res.text();
+    let json;
+    try {
+        json = rpcBody(text);
+    }
+    catch {
+        throw new ApiError(`${origin()} returned something that isn't JSON (HTTP ${res.status}).`, res.status);
+    }
+    if (res.status === 401) {
+        throw new ApiError(`${json?.error?.message ?? 'Not signed in.'}\n  Run "npx noslopui login" to sign in again.`, 401);
+    }
+    if (json?.error)
+        throw new ApiError(json.error.message ?? `The server refused the call (${json.error.code}).`);
+    const out = json?.result?.content?.[0]?.text ?? '';
+    let data = null;
+    try {
+        data = JSON.parse(out);
+    }
+    catch { }
+    return { isError: json?.result?.isError === true, text: out, data };
+}
+export async function whoami(key) {
+    let res;
+    try {
+        res = await fetch(`${origin()}/api/cli/me`, { headers: { authorization: `Bearer ${key}`, 'user-agent': USER_AGENT } });
+    }
+    catch {
+        throw new ApiError(`Could not reach ${origin()}. Check your connection, then run the command again.`);
+    }
+    let json = null;
+    try {
+        json = await res.json();
+    }
+    catch {
+        throw new ApiError(`${origin()} returned something that isn't JSON (HTTP ${res.status}).`, res.status);
+    }
+    if (!res.ok)
+        throw new ApiError(json?.message ?? `HTTP ${res.status}`, res.status);
+    return json;
+}
 /**
  * The workflow file. Fetched from the site, because the site is where it's
  * assembled — the same text the MCP server sends as its instructions, so the

package/dist/lib/json-file.js

@@ -18,7 +18,8 @@ export class ConfigUnreadableError extends Error {
     path;
     cause_;
     constructor(path, cause_) {
-        super(`${path} is not valid JSON, so it was left untouched.`);
+        const why = cause_ instanceof Error && cause_.message ? ` (${cause_.message})` : '';
+        super(`${path} couldn't be read safely${why}, so it was left untouched.`);
         this.path = path;
         this.cause_ = cause_;
         this.name = 'ConfigUnreadableError';
@@ -65,11 +66,15 @@ export function backupFile(path) {
 }
 /** Write via a temp file in the same directory, then rename over the target. */
 export function writeJsonFile(path, value, { indent = 2 } = {}) {
+    writeTextFile(path, `${JSON.stringify(value, null, indent)}\n`);
+}
+/** The same atomic write for a file that isn't JSON (Codex's config.toml). */
+export function writeTextFile(path, text) {
     const dir = dirname(path);
     mkdirSync(dir, { recursive: true });
     const temp = join(dir, `.noslopui-write-${process.pid}-${Date.now()}.tmp`);
     try {
-        writeFileSync(temp, `${JSON.stringify(value, null, indent)}\n`, 'utf8');
+        writeFileSync(temp, text, 'utf8');
         renameSync(temp, path);
     }
     catch (err) {

package/dist/lib/paths.js

@@ -0,0 +1,41 @@
+// Where agents keep their files. Every path starts from the home directory or
+// an environment variable the OS sets for it, never a hardcoded user folder, so
+// the tests can point all of them at a throwaway directory.
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+export const home = () => homedir();
+/** `%APPDATA%` on Windows (Roaming), where Electron apps and Devin keep user config. */
+export function appData() {
+    return process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+}
+/** `$XDG_CONFIG_HOME`, or `~/.config` — the Linux/macOS home for CLI config. */
+export function xdgConfig() {
+    return process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+}
+/** Where a VS Code-family app keeps its user settings, per OS. */
+export function vscodeUserDir(product = 'Code') {
+    if (process.platform === 'win32')
+        return join(appData(), product, 'User');
+    if (process.platform === 'darwin')
+        return join(homedir(), 'Library', 'Application Support', product, 'User');
+    return join(xdgConfig(), product, 'User');
+}
+/** The skills folder several agents share: Codex, Cursor, OpenCode, VS Code. */
+export const sharedSkillPath = () => join(homedir(), '.agents', 'skills', 'noslopui', 'SKILL.md');
+export function onPath(binary) {
+    const paths = (process.env.PATH ?? '').split(delimiter).filter(Boolean);
+    const suffixes = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''];
+    for (const dir of paths) {
+        for (const suffix of suffixes) {
+            try {
+                if (existsSync(join(dir, binary + suffix)))
+                    return true;
+            }
+            catch {
+                // An unreadable PATH entry is not our problem; keep looking.
+            }
+        }
+    }
+    return false;
+}

package/dist/lib/session.js

@@ -0,0 +1,49 @@
+// The CLI's own sign-in — what `noslopui search`, `get` and `whoami` use.
+//
+// It's an ordinary noslopUI API key, issued for the agent id `cli` by the same
+// browser approval `init` uses, and named after this machine on the account
+// page, where it can be revoked like any other. It's stored in the user's
+// config folder with owner-only permissions, and never printed in full.
+//
+// Agent keys stay in each agent's own config; this file is only the CLI's.
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { appData, xdgConfig } from './paths.js';
+export function sessionPath() {
+    const dir = process.platform === 'win32' ? join(appData(), 'noslopui') : join(xdgConfig(), 'noslopui');
+    return join(dir, 'credentials.json');
+}
+export function readSession() {
+    if (process.env.NOSLOPUI_API_KEY)
+        return { key: process.env.NOSLOPUI_API_KEY, savedAt: 'env' };
+    const path = sessionPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return typeof parsed?.key === 'string' && parsed.key ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSession(key) {
+    const path = sessionPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ key, savedAt: new Date().toISOString() }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    try {
+        // mode only applies when the file is created; tighten an existing one too.
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows ignores POSIX modes; the file is under the user's own profile.
+    }
+    return path;
+}
+export function clearSession() {
+    const path = sessionPath();
+    if (!existsSync(path))
+        return false;
+    rmSync(path, { force: true });
+    return true;
+}

package/dist/lib/skill-file.js

@@ -0,0 +1,26 @@
+// Writing and removing the skill file. Shared by every adapter, because several
+// agents read the same folder (`~/.agents/skills/` is read by Codex, Cursor,
+// OpenCode and VS Code alike) — one copy there serves all of them.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function installSkillAt(path, markdown) {
+    if (existsSync(path)) {
+        try {
+            if (readFileSync(path, 'utf8') === markdown)
+                return { path, changed: false };
+        }
+        catch {
+            // Unreadable but present: fall through and replace it.
+        }
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, markdown, 'utf8');
+    return { path, changed: true };
+}
+export function removeSkillAt(path) {
+    if (!existsSync(path))
+        return false;
+    // Only our own folder (…/skills/noslopui/), and only because we created it.
+    rmSync(dirname(path), { recursive: true, force: true });
+    return true;
+}

package/dist/lib/version.js

@@ -1,3 +1,3 @@
 // One place for the version, so package.json, --version and the User-Agent
 // can't disagree. Checked against package.json by a test.
-export const CLI_VERSION = '0.1.0';
+export const CLI_VERSION = '0.3.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noslopui",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Connect your coding agent to noslopUI \u2014 hand-crafted UI components and portable design systems, over MCP.",
   "keywords": [
     "mcp",