@pro-vi/designer 0.3.0

package/dist/cli.js

@@ -0,0 +1,618 @@
+#!/usr/bin/env -S node --import tsx
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { DesignerController } from "./designer-controller.js";
+import { listSessions, getSession } from "./session-store.js";
+import { createBrowser } from "./browser.js";
+import { writeTastingHtml, serveAndOpen } from "./tasting.js";
+import { sessionDir } from "./artifact-store.js";
+import { runSetup } from "./setup.js";
+import { startMcpServer } from "./mcp-server.js";
+import { REPO_ROOT } from "./repo-root.js";
+import { runHealth } from "./ui-anchors.js";
+const [, , cmd, ...rest] = process.argv;
+function parseFlags(args) {
+    const out = { _: [] };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (!a)
+            continue;
+        if (a.startsWith('--')) {
+            const parts = a.slice(2).split('=');
+            const k = parts[0] ?? '';
+            const v = parts[1] ?? args[++i] ?? true;
+            if (k)
+                out[k] = v;
+        }
+        else {
+            out._.push(a);
+        }
+    }
+    return out;
+}
+const flags = parseFlags(rest);
+const key = flags.key || 'default';
+async function main() {
+    if (flags.help === true || flags.h === true) {
+        if (cmd && HELP[cmd]) {
+            console.log(HELP[cmd]);
+        }
+        else {
+            console.log(TOP_HELP);
+        }
+        return;
+    }
+    switch (cmd) {
+        case 'open': {
+            const c = new DesignerController({ key });
+            console.log(JSON.stringify(await c.ensureReady(), null, 2));
+            break;
+        }
+        case 'session': {
+            const c = new DesignerController({ key });
+            const action = flags.action || 'status';
+            const name = flags.name;
+            const fidelity = flags.fidelity;
+            console.log(JSON.stringify(await c.session({ action, name, fidelity }), null, 2));
+            break;
+        }
+        case 'prompt': {
+            const prompt = await readPromptArg(flags);
+            if (!prompt)
+                throw new Error('Usage: designer prompt "<text>" | - (stdin) | --prompt-file path [--key k] [--file "f.html"]');
+            const c = new DesignerController({ key });
+            const res = await c.iterate(prompt, {
+                file: flags.file,
+                timeoutMs: flags.timeoutMs ? Number(flags.timeoutMs) : undefined,
+                stabilityMs: flags.stabilityMs ? Number(flags.stabilityMs) : undefined
+            });
+            if (res.url)
+                console.log(`\nTaste here: ${res.url}\n`);
+            console.log(JSON.stringify(res, null, 2));
+            break;
+        }
+        case 'create': {
+            const name = flags.name || flags._[0];
+            if (!name)
+                throw new Error('Usage: designer create <name> [--fidelity wireframe|highfi] [--key k]');
+            const fidelity = flags.fidelity || 'wireframe';
+            const c = new DesignerController({ key });
+            console.log(JSON.stringify(await c.createSession(name, fidelity), null, 2));
+            break;
+        }
+        case 'resume': {
+            const c = new DesignerController({ key });
+            console.log(JSON.stringify(await c.resumeSession(), null, 2));
+            break;
+        }
+        case 'snapshot': {
+            const c = new DesignerController({ key });
+            await c.ensureReady();
+            const filename = flags.file;
+            if (filename)
+                await c.openFile(filename);
+            const snap = await c.snapshotDesign();
+            if (snap.url)
+                console.log(`\nTaste here: ${snap.url}\n`);
+            console.log(JSON.stringify({ file: filename ?? null, url: snap.url, htmlBytes: snap.html?.length || 0, screenshotPath: snap.screenshotPath }, null, 2));
+            break;
+        }
+        case 'status':
+            console.log(JSON.stringify(getSession(key) || { key, empty: true }, null, 2));
+            break;
+        case 'list':
+            console.log(JSON.stringify(listSessions(), null, 2));
+            break;
+        case 'projects': {
+            const c = new DesignerController({ key });
+            console.log(JSON.stringify(await c.listProjects(), null, 2));
+            break;
+        }
+        case 'files': {
+            const c = new DesignerController({ key });
+            const detail = await c.listFilesDetailed();
+            if (!detail.authoritative) {
+                console.error(`[designer] Folders detected (${detail.folders.join(', ')}) — files under them are invisible to the live scrape. Run 'designer handoff --key ${key}' for authoritative file listing.`);
+            }
+            console.log(JSON.stringify(detail, null, 2));
+            break;
+        }
+        case 'open-file': {
+            const filename = flags._.join(' ');
+            if (!filename)
+                throw new Error('Usage: designer open-file "<name>.html" --key k');
+            const c = new DesignerController({ key });
+            console.log(JSON.stringify(await c.openFile(filename), null, 2));
+            break;
+        }
+        case 'ask': {
+            const prompt = await readPromptArg(flags);
+            if (!prompt)
+                throw new Error('Usage: designer ask "<text>" | - (stdin) | --prompt-file path --key k');
+            const c = new DesignerController({ key });
+            const r = await c.ask(prompt, {
+                file: flags.file,
+                timeoutMs: flags.timeoutMs ? Number(flags.timeoutMs) : undefined,
+                stabilityMs: flags.stabilityMs ? Number(flags.stabilityMs) : undefined
+            });
+            console.log(JSON.stringify(r, null, 2));
+            break;
+        }
+        case 'handoff': {
+            const c = new DesignerController({ key });
+            const r = await c.handoff({ openFile: flags.file });
+            console.log(JSON.stringify(r, null, 2));
+            break;
+        }
+        case 'fetch': {
+            const filename = flags._.join(' ');
+            if (!filename)
+                throw new Error('Usage: designer fetch "<name>.html" --key k [--out path]');
+            const c = new DesignerController({ key });
+            const r = await c.fetchFile(filename);
+            if (flags.out) {
+                fs.writeFileSync(flags.out, r.html);
+                console.log(JSON.stringify({ file: r.file, htmlBytes: r.htmlBytes, written: flags.out }, null, 2));
+            }
+            else {
+                console.log(JSON.stringify({ file: r.file, htmlBytes: r.htmlBytes, iframeSrc: r.iframeSrc, htmlPreview: r.html.slice(0, 200) }, null, 2));
+            }
+            break;
+        }
+        case 'close': {
+            await createBrowser({ session: `designer-${key}` }).close();
+            console.log('closed');
+            break;
+        }
+        case 'mcp': {
+            const sub = flags._[0];
+            if (sub !== 'serve') {
+                console.log("Usage: designer mcp serve\n  Starts the MCP stdio server. Used in 'claude mcp add --transport stdio designer -- designer mcp serve'.");
+                process.exit(sub ? 2 : 0);
+            }
+            await startMcpServer();
+            break;
+        }
+        case 'setup': {
+            const code = await runSetup();
+            process.exit(code);
+        }
+        case 'health': {
+            const browser = createBrowser({ session: `designer-${key}` });
+            const results = await runHealth(browser);
+            const worst = results.some((r) => r.status === 'fail') ? 'fail' : 'ok';
+            const icon = (s) => (s === 'ok' ? '✓' : s === 'fail' ? '✗' : '·');
+            for (const r of results) {
+                const line = `${icon(r.status)} [${r.category}] ${r.id} — ${r.description}${r.detail ? ' (' + r.detail + ')' : ''}`;
+                console.log(line);
+            }
+            const counts = results.reduce((acc, r) => {
+                acc[r.status] = (acc[r.status] || 0) + 1;
+                return acc;
+            }, {});
+            console.log(`\n${counts['ok'] || 0} ok, ${counts['fail'] || 0} fail, ${counts['skip'] || 0} skip`);
+            if (worst === 'fail')
+                process.exit(2);
+            break;
+        }
+        case 'doctor': {
+            const checks = await runDoctor();
+            const fail = checks.some((c) => c.status === 'fail');
+            console.log(checks.map((c) => `${statusIcon(c.status)} ${c.name}${c.detail ? ' — ' + c.detail : ''}`).join('\n'));
+            if (fail)
+                process.exit(2);
+            break;
+        }
+        case 'tasting': {
+            const base = sessionDir(key);
+            const handoffs = fs
+                .readdirSync(base)
+                .filter((e) => e.startsWith('handoff-'))
+                .map((e) => path.join(base, e))
+                .filter((p) => fs.statSync(p).isDirectory())
+                .sort();
+            const latest = handoffs[handoffs.length - 1];
+            if (!latest)
+                throw new Error(`No handoff bundle found for key=${key}. Run 'designer handoff --key ${key}' first.`);
+            const slugDirs = fs
+                .readdirSync(latest)
+                .filter((e) => e !== 'bundle.tar.gz')
+                .map((e) => path.join(latest, e))
+                .filter((p) => fs.statSync(p).isDirectory());
+            const slugDir = slugDirs[0];
+            if (!slugDir)
+                throw new Error('Bundle has no project subdirectory.');
+            const projectDir = path.join(slugDir, 'project');
+            if (!fs.existsSync(projectDir))
+                throw new Error(`Missing ${projectDir}`);
+            const files = [];
+            const stack = [''];
+            while (stack.length) {
+                const rel = stack.pop();
+                const abs = path.join(projectDir, rel);
+                for (const entry of fs.readdirSync(abs)) {
+                    const childRel = rel ? path.join(rel, entry) : entry;
+                    const childAbs = path.join(projectDir, childRel);
+                    if (fs.statSync(childAbs).isDirectory()) {
+                        stack.push(childRel);
+                        continue;
+                    }
+                    if (!entry.endsWith('.html') || entry === 'tasting.html' || entry === 'index.html')
+                        continue;
+                    files.push(childRel);
+                }
+            }
+            if (files.length === 0)
+                throw new Error('No .html variants found in bundle project dir.');
+            const variants = files.map((f) => ({
+                name: prettyName(path.basename(f)),
+                file: f
+            }));
+            const tastingPath = writeTastingHtml({ projectDir, variants, title: key });
+            const { url, port, pid } = await serveAndOpen(projectDir, { file: 'tasting.html' });
+            console.log(JSON.stringify({ ok: true, tastingPath, url, port, serverPid: pid, variants }, null, 2));
+            break;
+        }
+        case '--help':
+        case '-h':
+        case 'help':
+        case undefined:
+        default: {
+            const verb = cmd === 'help' ? flags._[0] : cmd && cmd !== '--help' && cmd !== '-h' ? cmd : undefined;
+            if (verb && HELP[verb]) {
+                console.log(HELP[verb]);
+            }
+            else {
+                console.log(TOP_HELP);
+            }
+            if (cmd && cmd !== 'help' && cmd !== '--help' && cmd !== '-h' && cmd !== undefined && !HELP[cmd]) {
+                process.exit(1);
+            }
+        }
+    }
+}
+const TOP_HELP = `designer — CLI + MCP for iterating on claude.ai/design
+
+Typical loop:
+  designer setup                                       (once per machine)
+  designer session --action create --name "X" --key x  start a project
+  designer prompt "design the …" --key x               prints 'Taste here: <url>'  ← open that
+  designer prompt - --key x < follow-up.txt            iterate until human says yes
+  designer handoff --key x                             bundle for code implementation
+
+Session lifecycle:
+  session [--action status|ensure_ready|resume|create] [--name N] [--fidelity wireframe|highfi] [--key k]
+                                               enter/inspect/transition (primary entry)
+  status [--key k]                             read stored state
+  list                                         list locally-tracked sessions
+  close [--key k]                              close browser (state preserved)
+
+Design operations (prompt + snapshot print 'Taste here: <url>' above the JSON):
+  prompt "<text>" | - | --prompt-file p [--key k] [--file f.html] [--timeoutMs n] [--stabilityMs n]
+  ask    "<text>" | - | --prompt-file p [--key k] [--file f.html]
+  snapshot [--key k] [--file f.html]
+
+File / project introspection:
+  projects                                     all Claude projects (scrapes home)
+  files [--key k]                              files in current project
+  open-file "<name>.html" [--key k]            switch open file
+  fetch "<name>.html" [--key k] [--out p]      fetch served HTML to disk
+
+Exit / promotion:
+  handoff [--key k] [--file "<name>.html"]     download tar.gz bundle (README + chats + source)
+  tasting [--key k]                            local full-viewport switcher for the latest bundle
+                                               (fallback when Claude's URL framing hurts taste)
+
+Setup / ops:
+  setup                                        one-call first-run
+  doctor                                       diagnose setup state
+  health                                       probe every UI anchor we depend on
+
+Internal:
+  mcp serve                                    start MCP stdio server ('claude mcp add' uses this)
+
+All verbs accept --key <k> for parallel isolation.
+Env: DESIGNER_CDP=9222 (auto-detected after 'designer setup').
+
+Per-verb detail: designer help <verb>   or   designer <verb> --help`;
+const HELP = {
+    session: `designer session — enter, inspect, or transition a claude.ai/design session.
+
+Flags:
+  --action <a>    status (default, read-only) | ensure_ready | resume | create
+  --name <N>      required when --action create
+  --fidelity <f>  wireframe | highfi — locked at creation, default wireframe
+  --key <k>       stable session key (e.g., feature name), defaults to 'default'
+
+Examples:
+  designer session                                        # read status of 'default'
+  designer session --action create --name "feat X" --fidelity highfi --key feat-x
+  designer session --action resume --key feat-x
+  designer session --key feat-x                           # status for feat-x`,
+    prompt: `designer prompt — modify the design. Waits for HTML to change and stabilize.
+
+Input (pick one):
+  "<text>"                literal argument (positional)
+  -                       read from stdin
+  --prompt-file <path>    read from file
+
+Flags:
+  --key <k>               session to target (default: 'default')
+  --file <f.html>         switch to this file before prompting
+  --timeoutMs <n>         default 20 minutes
+  --stabilityMs <n>       default 4 seconds
+
+Output: prints 'Taste here: <url>' then JSON metadata (done, newFiles, htmlPath, screenshotPath,
+htmlHash, chatReply). HTML is written to disk (read htmlPath if needed); it's not inline.
+
+Auto-appended to every prompt: 'Keep all generated files at the project root; no subfolders.'
+Override by explicitly contradicting it in your prompt text.
+
+Examples:
+  designer prompt "add a Remember-me checkbox" --key feat-x
+  designer prompt --prompt-file ./brief.md --key feat-x
+  cat follow-up.txt | designer prompt - --key feat-x`,
+    ask: `designer ask — Q&A with the design assistant. No file changes; returns the reply.
+
+Input (pick one):
+  "<text>"                literal argument
+  -                       read from stdin
+  --prompt-file <path>    read from file
+
+Flags:
+  --key <k>               session to target
+  --file <f.html>         switch to this file first (gives Claude context)
+  --timeoutMs <n>         default 5 minutes
+
+Output: JSON with { ok, reply, elapsedMs, failureMode }.
+
+Use for 'why did you choose X?', 'compare A and B', 'suggest 3 alternatives before I commit'.
+Distinct from prompt because it watches the chat panel, not the served HTML.`,
+    snapshot: `designer snapshot — capture current design state without prompting.
+
+Flags:
+  --key <k>               session to target
+  --file <f.html>         switch to this file first
+
+Output: prints 'Taste here: <url>' then JSON with { file, url, htmlBytes, screenshotPath }.
+Useful when you want to inspect a variant or save the current state to disk without iterating.`,
+    handoff: `designer handoff — trigger Export→Handoff and download the tar.gz bundle.
+
+Flags:
+  --key <k>               session to target
+  --file <name.html>      switch to this file first (marks it as the primary in the bundle)
+
+Bundle contains:
+  README.md       handoff protocol for the implementing agent
+  chats/chat1.md  full transcript — every prompt + reply, verbatim (the decision record)
+  project/*       all design files (HTML, standalone HTML, JSX, CSS)
+
+Lands under ./artifacts/{key}/handoff-{timestamp}/. Non-optional for code promotion — the
+implementing agent (Claude Code downstream) reads README + chats first, then builds in real code.`,
+    tasting: `designer tasting — build a local full-viewport switcher over the latest handoff bundle.
+
+Flags:
+  --key <k>               session to target
+  --port <n>              default auto-assigned from 8765
+
+What it does: walks the latest handoff's project/ dir, writes tasting.html with variant tabs
+(keyboard 1/N to switch) + notes field (persisted in localStorage), starts http.server, opens
+the browser.
+
+Use when Claude.ai/design's IDE chrome (chat panel, toolbar) is stealing viewport space that
+the design needs for judgment. Requires a prior 'designer handoff'.`,
+    setup: `designer setup — one-call first-run for this machine.
+
+Runs in order, idempotent at every step:
+  1. npm install (if missing)
+  2. Check agent-browser on PATH
+  3. If non-debug Chrome running → ask you to Cmd+Q, poll until quit
+  4. Auto-launch debug Chrome with --remote-debugging-port + dedicated --user-data-dir
+  5. Poll until you sign in to Claude and reach /design
+  6. Copy the designer-loop skill to ~/.claude/skills/
+  7. Register the MCP server with Claude Code at user scope
+
+Re-run any time; every step no-ops when already satisfied.`,
+    doctor: `designer doctor — diagnose first-run setup state without changing anything.
+
+Checks: agent-browser on PATH, CDP reachable at DESIGNER_CDP port, a /design tab is open,
+selectors.json present, designer-loop skill installed at ~/.claude/skills/, MCP registration.
+
+Exits with code 2 if any check fails.`,
+    health: `designer health — probe every UI anchor this MCP depends on.
+
+Walks the current Chrome state (home / session) and checks each selector / button / URL /
+DOM pattern we rely on. Reports pass / fail / skip per anchor with actionable detail.
+
+Exit code 2 on any fail — wire into cron or CI to catch UI regressions (e.g., claude.ai
+moving the Share button) before users do.`,
+    'mcp': `designer mcp serve — start the MCP stdio server.
+
+Used by 'claude mcp add':
+  claude mcp add --transport stdio designer -- env DESIGNER_CDP=9222 designer mcp serve
+
+Handled automatically by 'designer setup'.`,
+    files: `designer files — list filenames in the current project (scrapes the design-files panel).
+
+Flags: --key <k>
+
+Note: the scrape is flat-only. Files nested under folders (directions/, variants/) are
+invisible to this command. The handoff bundle is always folder-aware — use that for
+authoritative file listing.`,
+    projects: `designer projects — list all Claude design projects visible on /design home.
+
+Output: JSON array of { name, sub (subtitle, e.g., 'Today'), url }.`,
+    'open-file': `designer open-file "<name>.html" — switch the currently-open file in the project.
+
+Flags: --key <k>
+
+URL-encodes the filename and navigates to ?file=<name>. Useful mid-iteration.`,
+    fetch: `designer fetch "<name>.html" — fetch a file's served HTML.
+
+Flags:
+  --key <k>
+  --out <path>   write HTML to this path
+
+Without --out, returns JSON with a 200-char preview. With --out, writes the full HTML and
+returns { file, htmlBytes, written }.`,
+    close: `designer close — close the browser (state on disk is preserved).
+
+Flags: --key <k>
+
+Rarely needed; the debug Chrome window persists across designer calls. Primary use is
+test cleanup.`,
+    status: `designer status — print stored state for a session.
+
+Flags: --key <k>
+
+Output: the full session record from ~/.designer/sessions.json — createdAt, designUrl,
+name, fidelity, lastUrl, full history.`,
+    list: `designer list — list all locally-tracked sessions from ~/.designer/sessions.json.
+
+No flags. Output: JSON array of session records.`
+};
+function statusIcon(s) {
+    return s === 'ok' ? '✓' : s === 'warn' ? '⚠' : '✗';
+}
+async function runDoctor() {
+    const out = [];
+    out.push(checkDeps());
+    out.push(await checkAgentBrowser());
+    out.push(await checkCdp());
+    out.push(await checkOnDesignSurface());
+    out.push(checkSelectors());
+    out.push(checkSkillInstalled());
+    out.push(await checkMcpRegistered());
+    return out;
+}
+function checkDeps() {
+    const nm = path.join(REPO_ROOT, 'node_modules');
+    if (!fs.existsSync(nm)) {
+        return { name: 'dependencies installed', status: 'fail', detail: 'node_modules missing — run `designer setup` or `npm install`' };
+    }
+    const rootLock = path.join(REPO_ROOT, 'package-lock.json');
+    const innerLock = path.join(nm, '.package-lock.json');
+    if (!fs.existsSync(rootLock) || !fs.existsSync(innerLock)) {
+        return { name: 'dependencies installed', status: 'ok', detail: 'node_modules present (no lockfile to compare)' };
+    }
+    const h = (p) => createHash('sha1').update(fs.readFileSync(p)).digest('hex');
+    if (h(rootLock) !== h(innerLock)) {
+        return { name: 'dependencies installed', status: 'warn', detail: 'node_modules stale (lockfile mismatch) — run `npm install`' };
+    }
+    return { name: 'dependencies installed', status: 'ok', detail: 'in sync with package-lock' };
+}
+async function checkAgentBrowser() {
+    return new Promise((resolve) => {
+        const c = spawn('agent-browser', ['--version'], { stdio: 'pipe' });
+        let v = '';
+        c.stdout.on('data', (d) => (v += d.toString()));
+        c.on('error', () => resolve({ name: 'agent-browser installed', status: 'fail', detail: 'binary not found on PATH; install from https://github.com/agent-browser/agent-browser' }));
+        c.on('close', () => resolve({ name: 'agent-browser installed', status: 'ok', detail: v.trim() || 'present' }));
+    });
+}
+async function checkCdp() {
+    const port = process.env.DESIGNER_CDP || '9222';
+    if (!process.env.DESIGNER_CDP) {
+        return { name: `CDP at port ${port}`, status: 'warn', detail: 'DESIGNER_CDP not set; defaulting to 9222. export DESIGNER_CDP=9222 to silence.' };
+    }
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/json/version`);
+        if (!res.ok)
+            return { name: `CDP at port ${port}`, status: 'fail', detail: `HTTP ${res.status}` };
+        const j = await res.json();
+        return { name: `CDP at port ${port}`, status: 'ok', detail: j.Browser || 'connected' };
+    }
+    catch (e) {
+        return {
+            name: `CDP at port ${port}`,
+            status: 'fail',
+            detail: `not reachable. Run: ./scripts/designer-chrome.sh (launches Chrome with --remote-debugging-port=${port} in a dedicated profile)`
+        };
+    }
+}
+async function checkOnDesignSurface() {
+    const port = process.env.DESIGNER_CDP || '9222';
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/json/list`);
+        if (!res.ok)
+            return { name: 'logged into claude.ai/design', status: 'fail', detail: `HTTP ${res.status}` };
+        const tabs = await res.json();
+        const onDesign = tabs.find((t) => t.url && /claude\.ai\/design/.test(t.url));
+        if (!onDesign)
+            return { name: 'logged into claude.ai/design', status: 'warn', detail: 'no tab on claude.ai/design — sign in and navigate there in the debug Chrome window' };
+        if (/login|sign in/i.test(onDesign.title || ''))
+            return { name: 'logged into claude.ai/design', status: 'fail', detail: 'on a login page; sign in inside the debug Chrome window' };
+        return { name: 'logged into claude.ai/design', status: 'ok', detail: onDesign.url };
+    }
+    catch {
+        return { name: 'logged into claude.ai/design', status: 'fail', detail: 'CDP not reachable; fix CDP first' };
+    }
+}
+function checkSelectors() {
+    try {
+        fs.readFileSync(path.join(REPO_ROOT, 'selectors.json'), 'utf8');
+        return { name: 'selectors.json present', status: 'ok' };
+    }
+    catch {
+        return { name: 'selectors.json present', status: 'fail', detail: 'missing — re-clone or restore from git' };
+    }
+}
+function checkSkillInstalled() {
+    const home = process.env.HOME || '';
+    const skillDir = path.join(home, '.claude', 'skills', 'designer-loop');
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) {
+        return { name: 'designer-loop skill installed', status: 'warn', detail: `not at ${skillPath}; agent will lack loop guidance` };
+    }
+    try {
+        if (fs.lstatSync(skillDir).isSymbolicLink()) {
+            return { name: 'designer-loop skill installed', status: 'ok', detail: `${skillDir} → ${fs.realpathSync(skillDir)}` };
+        }
+    }
+    catch { }
+    return { name: 'designer-loop skill installed', status: 'ok', detail: skillDir };
+}
+async function checkMcpRegistered() {
+    const which = spawnSync('which', ['claude'], { stdio: 'pipe' });
+    if (which.status !== 0) {
+        return { name: 'MCP registered with Claude Code', status: 'warn', detail: 'claude CLI not on PATH; install Claude Code to verify' };
+    }
+    const list = spawnSync('claude', ['mcp', 'list'], { stdio: 'pipe' });
+    if (list.status !== 0) {
+        return { name: 'MCP registered with Claude Code', status: 'fail', detail: `\`claude mcp list\` exited ${list.status}` };
+    }
+    const stdout = list.stdout?.toString() || '';
+    const line = stdout.split('\n').find((l) => /(\s|^)designer\b/i.test(l));
+    if (!line) {
+        return { name: 'MCP registered with Claude Code', status: 'warn', detail: 'not registered — run `designer setup` or see README' };
+    }
+    return { name: 'MCP registered with Claude Code', status: 'ok', detail: line.trim() };
+}
+async function readPromptArg(flags) {
+    if (flags['prompt-file']) {
+        const p = flags['prompt-file'];
+        return fs.readFileSync(p, 'utf8').trim();
+    }
+    const positional = flags._.join(' ').trim();
+    if (positional === '-') {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk.toString());
+        return chunks.join('').trim();
+    }
+    return positional;
+}
+function prettyName(filename) {
+    return filename
+        .replace(/\.html$/i, '')
+        .replace(/^(?:v\d+-|Philemon\s*[—-]\s*|.*?\s-\s)/i, '')
+        .replace(/[-_]+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, (c) => c.toUpperCase()) || filename;
+}
+main().catch((e) => {
+    console.error(e.message);
+    process.exit(1);
+});