sella-cli 0.5.0 → 0.6.0

package/README.md

@@ -4,18 +4,22 @@ Terminal onboarding for [Sella](https://sella.network) — the marketplace where
 models, and machine-payable APIs.
 
 ```bash
-npx sella-cli init
+npx sella-cli
 ```
 
-`init` detects your agent clients (Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Cline),
-installs the Sella MCP server into each, and walks you through pairing. Installed users get the
-`sella` binary.
+That single command is the whole onboarding: with no stored credentials and a human at the
+terminal, the guided wizard starts by itself (`init` is the explicit spelling). It previews the
+marketplace, detects your agent clients (Claude Code, Claude Desktop, Cursor, Windsurf, VS Code,
+Cline), installs the Sella MCP server into each, pairs the machine (arrow-key choice of setup code
+or email + 6-digit code), wires your key into the client configs, and finishes with a live
+`doctor` verification. Installed users get the `sella` binary; `npm install` also prints a
+one-line pointer after install (silent in CI and non-TTY runs — installs are never interrupted).
 
 ## Commands
 
 | Command | What it does |
 |---|---|
-| `sella init` | Detect clients → install the Sella MCP server → pair → verify |
+| `sella init` | Guided wizard: detect clients → install the Sella MCP server → pair → verify (auto-runs on bare `sella` when unpaired) |
 | `sella sandbox <query>` | Try Sella with **no signup** — search the live marketplace (rate-limited) |
 | `sella pair` | Pair this machine only (`--setup-code <code>` / `SELLA_SETUP_CODE`, or `--email` + OTP) |
 | `sella clients` | List detected clients (`--install` to write configs, `--client a,b` to filter, `--dry-run`) |
@@ -34,7 +38,8 @@ your wallets, just without the label.
 ## Contract (every command)
 
 - `--json` → exactly one JSON document on stdout; errors on stderr; meaningful exit codes.
-- `--yes` / env vars for every prompt — agents run this CLI too; nothing may hang on a TTY.
+- `--yes` / env vars for every prompt — agents run this CLI too; nothing may hang on a TTY (the
+  wizard renders as plain sequential lines off-TTY and never auto-starts in `--yes`/`--json` runs).
 - `NO_COLOR` / `--no-color` honored; no spinner-only feedback; color never carries meaning alone.
 - Config writes are idempotent, preserve other servers, and leave a one-time `.sella-backup`.
 - `SELLA_MCP_URL` overrides the endpoint (self-hosted / staging).

package/dist/index.js

@@ -10,8 +10,9 @@ import { sandboxSearch } from './api.js';
 import { getFundingInfo, annotateFunding } from './fund.js';
 import { capabilityLabel } from './chains.js';
 import { defaultIo, Printer } from './output.js';
+import { Ui } from './ui.js';
 const DEFAULT_MCP_URL = 'https://sella.network/api/mcp';
-const VERSION = '0.5.0';
+const VERSION = '0.6.0';
 function parseFlags(argv) {
     const flags = {
         json: false, yes: false, noColor: false, dryRun: false, noKeychain: false,
@@ -53,7 +54,8 @@ const HELP = `sella — the Sella onboarding CLI
 Usage: sella <command> [options]
 
 Commands:
-  init       Install the Sella MCP server into your agent clients, pair, done
+  init       Guided onboarding: install the Sella MCP server, pair, verify
+             (also runs when you invoke \`sella\` with no command and no credentials yet)
   pair       Pair this machine only (setup code or email + OTP)
   sandbox    Try Sella with no signup — search the live marketplace (rate-limited)
   clients    List detected agent clients (--install to write configs)
@@ -87,7 +89,16 @@ function selectClientIds(flags, detected) {
     }
     return detected.filter((c) => c.installed).map((c) => c.id);
 }
-function installAll(ctx, flags, printer, apiKey) {
+function uiEmitter(ui, printer) {
+    return {
+        info: (t) => ui.step(t),
+        ok: (t) => ui.ok(t),
+        warn: (t) => ui.warn(t),
+        // Errors always reach stderr too (screen readers, log capture, --json pipelines).
+        error: (t) => printer.error(t),
+    };
+}
+function installAll(ctx, flags, emit, apiKey) {
     const detected = detectClients(ctx.env);
     const targets = selectClientIds(flags, detected);
     const results = [];
@@ -96,13 +107,13 @@ function installAll(ctx, flags, printer, apiKey) {
         try {
             const result = installSellaIntoClient(id, { mcpUrl: ctx.mcpUrl, env: ctx.env, dryRun: flags.dryRun, apiKey });
             results.push({ ...result });
-            printer.ok(`${id}: ${flags.dryRun ? `would be ${result.action}` : result.action} → ${result.configPath}`);
+            emit.ok(`${id}: ${flags.dryRun ? `would be ${result.action}` : result.action} → ${result.configPath}`);
         }
         catch (err) {
             failed = true;
             const message = err instanceof Error ? err.message : String(err);
             results.push({ id, error: message });
-            printer.error(`${id}: ${message}`);
+            emit.error(`${id}: ${message}`);
         }
     }
     return { results, failed, targets };
@@ -120,26 +131,26 @@ function makeAsk(ctx) {
         }
     };
 }
-async function runPair(ctx, flags, printer) {
+async function runPair(ctx, flags, emit, extra = {}) {
     const outcome = await pair({
         mcpUrl: ctx.mcpUrl,
         env: ctx.env,
         interactive: ctx.io.isTTY && !flags.yes && !flags.json,
-        setupCode: flags.setupCode || ctx.io.env.SELLA_SETUP_CODE,
-        email: flags.email,
+        setupCode: extra.setupCode ?? (flags.setupCode || ctx.io.env.SELLA_SETUP_CODE),
+        email: extra.email ?? flags.email,
         allowKeychain: !flags.noKeychain && !ctx.io.env.SELLA_NO_KEYCHAIN,
-        ask: makeAsk(ctx),
+        ask: extra.ask ?? makeAsk(ctx),
     });
     if (!outcome.ok) {
-        printer.error(outcome.error);
+        emit.error(outcome.error);
         return { code: outcome.exitCode, summary: { paired: false, error: outcome.error } };
     }
-    printer.ok(`Paired via ${outcome.method} — status: ${outcome.payload.status || 'ok'}`);
+    emit.ok(`Paired via ${outcome.method} — status: ${outcome.payload.status || 'ok'}`);
     for (const file of outcome.save.files)
-        printer.ok(`wrote ${file}`);
-    printer.info(outcome.save.custodyNote);
+        emit.ok(`wrote ${file}`);
+    emit.info(outcome.save.custodyNote);
     if (outcome.payload.agentWallet?.status === 'unavailable') {
-        printer.warn(`AgentWallet not provisioned (${outcome.payload.agentWallet.reason || 'backend unavailable'}) — MCP access still works; re-run \`sella pair\` later.`);
+        emit.warn(`AgentWallet not provisioned (${outcome.payload.agentWallet.reason || 'backend unavailable'}) — MCP access still works; re-run \`sella pair\` later.`);
     }
     return {
         code: 0,
@@ -154,43 +165,129 @@ async function runPair(ctx, flags, printer) {
         },
     };
 }
-async function previewSandbox(ctx, flags, printer) {
-    if (flags.json)
-        return; // cosmetic; skip in machine mode
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/**
+ * Wizard input collection: honors --setup-code/--email/SELLA_SETUP_CODE first (identical to the
+ * headless path), and only prompts when a human is present.
+ */
+async function collectPairChoice(ui, flags, ctx) {
+    const preset = flags.setupCode || ctx.io.env.SELLA_SETUP_CODE;
+    if (preset || flags.email || !ui.interactive)
+        return { setupCode: preset, email: flags.email };
+    const method = await ui.select('How do you want to pair this machine?', [
+        { value: 'setup-code', label: 'Setup code', hint: 'paste one from the Sella dashboard' },
+        { value: 'email-otp', label: 'Email + code', hint: 'we email you a 6-digit code' },
+    ]);
+    if (method === 'setup-code') {
+        const code = await ui.text('Paste your setup code', {
+            placeholder: 'SELLA-XXXX-XXXX-XXXX-XXXX',
+            validate: (v) => (v ? undefined : 'A setup code is required — mint one on the dashboard (Connect your agent).'),
+        });
+        return { setupCode: code };
+    }
+    const email = await ui.text('Email for your Sella account', {
+        validate: (v) => (EMAIL_RE.test(v) ? undefined : 'Enter a valid email address.'),
+    });
+    return { email };
+}
+/** The one prompt pair() asks itself (the emailed OTP) — styled when the wizard is active. */
+function wizardAsk(ui, ctx) {
+    if (!ui.interactive)
+        return makeAsk(ctx);
+    return async (question) => {
+        if (/6-digit/i.test(question)) {
+            return ui.text('6-digit code from your inbox', {
+                validate: (v) => (/^\d{6}$/.test(v) ? undefined : 'Enter exactly the 6 digits from the email.'),
+            });
+        }
+        return ui.text(question.replace(/:\s*$/, ''));
+    };
+}
+async function cmdInit(ctx, flags, printer) {
+    const ui = new Ui(ctx.io, { json: flags.json, noColor: flags.noColor, yes: flags.yes });
+    const emit = ui.pretty ? uiEmitter(ui, printer) : printer;
+    const origin = ctx.mcpUrl.replace(/\/api\/mcp\/?$/, '') || 'https://sella.network';
+    let host = ctx.mcpUrl;
+    try {
+        host = new URL(ctx.mcpUrl).host;
+    }
+    catch {
+        /* keep full URL */
+    }
+    ui.intro('Sella — connect your agents', `v${VERSION} · ${host}`);
+    // A taste of the marketplace (free sandbox, best-effort — never blocks onboarding).
+    const taste = ui.spinner('Peeking at the marketplace (free, no signup)…');
     try {
         const result = await sandboxSearch(ctx.mcpUrl, 'data');
-        const n = result.datasets.length + result.apis.length;
-        if (n === 0)
-            return;
-        printer.info('Here’s a taste of what your agent can buy on Sella (no signup needed):');
-        for (const d of result.datasets.slice(0, 2))
-            printer.info(`  dataset  ${d.title || d.id}`);
-        for (const a of result.apis.slice(0, 2))
-            printer.info(`  api      ${a.name || ''}`);
-        printer.info('');
+        const picks = [
+            ...result.datasets.slice(0, 2).map((d) => `dataset  ${d.title || d.id}`),
+            ...result.apis.slice(0, 2).map((a) => `api      ${a.name || ''}`),
+        ];
+        taste.succeed(picks.length ? 'A taste of what your agent can buy here:' : 'Marketplace preview is empty right now.');
+        for (const p of picks)
+            ui.detail(p);
     }
     catch {
-        /* best-effort — never blocks onboarding */
+        taste.succeed('Marketplace preview skipped.');
     }
-}
-async function cmdInit(ctx, flags, printer) {
-    printer.info('Sella init — 1/3 install, 2/3 pair, 3/3 verify.\n');
-    await previewSandbox(ctx, flags, printer);
-    const install = installAll(ctx, flags, printer);
-    if (install.targets.length === 0) {
-        printer.error('No agent clients found (and none specified via --client). Nothing to install into.');
+    ui.bar();
+    // Step 1/3 — install
+    const detected = detectClients(ctx.env);
+    const targets = selectClientIds(flags, detected);
+    if (targets.length === 0) {
+        emit.error('No agent clients found (and none specified via --client). Nothing to install into.');
         printer.jsonOut({ installed: [], paired: false, error: 'no_clients' });
+        ui.outro('Nothing to do.');
         return 2;
     }
-    printer.info('\nPairing this machine…');
-    const paired = await runPair(ctx, flags, printer);
+    ui.step(`Step 1/3 · Install the Sella MCP server (${targets.join(', ')})`);
+    const install = installAll(ctx, flags, emit);
+    ui.bar();
+    // Step 2/3 — pair
+    ui.step('Step 2/3 · Pair this machine with your Sella account');
+    const choice = await collectPairChoice(ui, flags, ctx);
+    if (choice.email)
+        ui.step(`Requesting a verification code for ${choice.email}…`);
+    const paired = await runPair(ctx, flags, emit, { ...choice, ask: wizardAsk(ui, ctx) });
     let reinstalled = [];
     if (paired.code === 0 && paired.apiKey && !flags.dryRun) {
-        reinstalled = installAll(ctx, flags, printer, paired.apiKey).results;
-        printer.info('\nDone. Your agent clients are connected to Sella — fund your wallet to enable paid calls:');
-        printer.info('  https://sella.network/dashboard/funding');
+        ui.bar();
+        ui.step('Wiring your API key into the client configs');
+        reinstalled = installAll(ctx, flags, emit, paired.apiKey).results;
+    }
+    // Step 3/3 — verify (report-only: exit codes stay install/pair-driven so automation is stable)
+    let verifySummary;
+    if (paired.code === 0 && !flags.dryRun) {
+        ui.bar();
+        const sp = ui.spinner('Step 3/3 · Verifying the install (sella doctor)…');
+        try {
+            const verify = await runDoctor({ mcpUrl: ctx.mcpUrl, env: ctx.env });
+            const passed = verify.checks.filter((c) => c.ok).length;
+            sp.succeed(`Step 3/3 · Verified — ${passed}/${verify.checks.length} doctor checks passed`);
+            for (const check of verify.checks.filter((c) => !c.ok)) {
+                ui.warn(`${check.label} — ${check.detail}`);
+                if (check.fix)
+                    ui.detail(`fix: ${check.fix}`);
+            }
+            verifySummary = { ok: verify.ok, passed, total: verify.checks.length };
+        }
+        catch (err) {
+            sp.fail('Step 3/3 · Verify could not run (network?) — try `sella doctor` later.');
+            verifySummary = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
     }
-    printer.jsonOut({ installed: install.results, pairing: paired.summary, reinstalled });
+    if (paired.code === 0) {
+        ui.note('Sella is connected', [
+            `Fund your agent wallet: ${origin}/dashboard/funding`,
+            'Try it free:  sella sandbox "web search"',
+            'Health check: sella doctor',
+        ]);
+        ui.outro(flags.dryRun ? 'Dry run complete — nothing was written.' : 'Done — your agents can now buy on Sella.');
+    }
+    else {
+        ui.outro('Pairing incomplete — fix the issue above, then re-run `sella init`.');
+    }
+    printer.jsonOut({ installed: install.results, pairing: paired.summary, reinstalled, verify: verifySummary });
     return install.failed ? 1 : paired.code;
 }
 export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
@@ -202,7 +299,19 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
         io.stdout(VERSION);
         return 0;
     }
-    if (flags.help || !command) {
+    if (flags.help) {
+        io.stdout(HELP);
+        return 0;
+    }
+    if (!command) {
+        // Bare `sella` / `npx sella-cli`: a human at a TTY with no credentials yet gets the
+        // onboarding wizard directly (that IS the task); everyone else gets help. Never in
+        // --json/--yes runs — automation must not fall into an interactive flow.
+        const interactive = io.isTTY && Boolean(process.stdin.isTTY) && !flags.json && !flags.yes;
+        if (interactive && !loadStoredKey(ctx.env)) {
+            printer.info('No Sella credentials on this machine yet — starting onboarding (Ctrl+C to abort, `sella --help` for commands).');
+            return await cmdInit(ctx, flags, printer);
+        }
         io.stdout(HELP);
         return 0;
     }
@@ -230,7 +339,21 @@ export async function runCli(argv, io = defaultIo(), env = defaultEnv()) {
                 return failed ? 1 : 0;
             }
             case 'pair': {
-                const paired = await runPair(ctx, flags, printer);
+                const ui = new Ui(ctx.io, { json: flags.json, noColor: flags.noColor, yes: flags.yes });
+                const emit = ui.pretty ? uiEmitter(ui, printer) : printer;
+                let host = ctx.mcpUrl;
+                try {
+                    host = new URL(ctx.mcpUrl).host;
+                }
+                catch {
+                    /* keep full URL */
+                }
+                ui.intro('Sella — pair this machine', `v${VERSION} · ${host}`);
+                const choice = await collectPairChoice(ui, flags, ctx);
+                if (choice.email)
+                    ui.step(`Requesting a verification code for ${choice.email}…`);
+                const paired = await runPair(ctx, flags, emit, { ...choice, ask: wizardAsk(ui, ctx) });
+                ui.outro(paired.code === 0 ? 'Paired — try `sella doctor` next.' : 'Pairing failed — see above.');
                 printer.jsonOut(paired.summary || {});
                 return paired.code;
             }

package/dist/postinstall.js

@@ -0,0 +1,38 @@
+/**
+ * npm postinstall pointer (CLI sprint C7). Constraints that shape this file:
+ * - npm ≥7 runs dependency lifecycle scripts with piped, usually-hidden output, and CI runs
+ *   must NEVER gain an interactive step — so we do not auto-launch the wizard here.
+ * - Instead the wizard auto-starts on the first bare `sella` / `npx sella-cli` run with no
+ *   stored credentials (see index.ts). This script only prints a one-glance pointer when a
+ *   human terminal will actually show it.
+ * - It must never fail or block an install: everything is wrapped, and we always exit 0.
+ */
+function main() {
+    const env = process.env;
+    const ci = Boolean(env.CI || env.CONTINUOUS_INTEGRATION || env.GITHUB_ACTIONS || env.BUILD_NUMBER || env.TEAMCITY_VERSION);
+    if (ci || !process.stdout.isTTY)
+        return;
+    const globalInstall = env.npm_config_global === 'true';
+    const cmd = globalInstall ? 'sella' : 'npx sella';
+    const color = !env.NO_COLOR;
+    const dim = (s) => (color ? `\x1b[90m${s}\x1b[0m` : s);
+    const bold = (s) => (color ? `\x1b[1m${s}\x1b[0m` : s);
+    process.stdout.write([
+        '',
+        `  ${bold('sella-cli installed.')}`,
+        `  Finish onboarding (installs the MCP server into your agent clients, pairs, verifies):`,
+        '',
+        `      ${bold(cmd)}`,
+        '',
+        `  ${dim('Docs: https://sella.network · Try without an account: `' + cmd + ' sandbox "web search"`')}`,
+        '',
+    ].join('\n'));
+}
+try {
+    main();
+}
+catch {
+    /* a postinstall pointer must never break an install */
+}
+process.exit(0);
+export {};

package/dist/ui.js

@@ -0,0 +1,310 @@
+import * as readline from 'node:readline/promises';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+let cursorHooked = false;
+function ensureCursorRestoredOnExit() {
+    if (cursorHooked)
+        return;
+    cursorHooked = true;
+    process.on('exit', () => {
+        if (process.stdout.isTTY)
+            process.stdout.write('\x1b[?25h');
+    });
+}
+export class Ui {
+    io;
+    /** Glyph/ANSI rendering is worth doing (real TTY, not machine output). */
+    pretty;
+    /** Prompts are allowed (pretty or plain — but a human is present). */
+    interactive;
+    color;
+    quiet;
+    constructor(io, opts) {
+        this.io = io;
+        this.quiet = opts.json;
+        this.pretty = io.isTTY && Boolean(process.stdout.isTTY) && !opts.json;
+        this.color = this.pretty && !opts.noColor && !io.env.NO_COLOR;
+        this.interactive = io.isTTY && Boolean(process.stdin.isTTY) && !opts.json && !opts.yes;
+    }
+    // ── paint helpers ──────────────────────────────────────────────────────────
+    paint(code, text) {
+        return this.color ? `\x1b[${code}m${text}\x1b[0m` : text;
+    }
+    dim(text) {
+        return this.paint('90', text);
+    }
+    accent(text) {
+        return this.paint('36', text);
+    }
+    width() {
+        return Math.max(40, Math.min(process.stdout.columns || 80, 100));
+    }
+    out(text) {
+        if (!this.quiet)
+            this.io.stdout(text);
+    }
+    // ── static rendering ───────────────────────────────────────────────────────
+    intro(title, meta) {
+        if (this.quiet)
+            return;
+        if (!this.pretty) {
+            this.out(`${title}${meta ? ` (${meta})` : ''}`);
+            return;
+        }
+        this.out('');
+        this.out(`${this.dim('┌')}  ${this.paint('1', title)}${meta ? `  ${this.dim(meta)}` : ''}`);
+        this.bar();
+    }
+    outro(text) {
+        if (this.quiet)
+            return;
+        if (!this.pretty) {
+            this.out(text);
+            return;
+        }
+        this.out(`${this.dim('└')}  ${text}`);
+        this.out('');
+    }
+    bar() {
+        if (!this.quiet && this.pretty)
+            this.out(this.dim('│'));
+    }
+    step(text) {
+        if (this.quiet)
+            return;
+        this.out(this.pretty ? `${this.dim('◇')}  ${text}` : text);
+    }
+    ok(text) {
+        if (this.quiet)
+            return;
+        this.out(this.pretty ? `${this.paint('32', '◇')}  ${text}` : `ok ${text}`);
+    }
+    warn(text) {
+        if (this.quiet)
+            return;
+        this.out(this.pretty ? `${this.paint('33', '▲')}  ${text}` : `warn ${text}`);
+    }
+    fail(text) {
+        if (this.quiet)
+            return;
+        this.out(this.pretty ? `${this.paint('31', '✕')}  ${text}` : `error ${text}`);
+    }
+    /** Indented supporting line under a step. */
+    detail(text) {
+        if (this.quiet)
+            return;
+        this.out(this.pretty ? `${this.dim('│')}    ${text}` : `    ${text}`);
+    }
+    /** Boxed panel for the final summary / next steps. */
+    note(title, lines) {
+        if (this.quiet)
+            return;
+        if (!this.pretty) {
+            this.out('');
+            this.out(title);
+            for (const line of lines)
+                this.out(`  ${line}`);
+            return;
+        }
+        const inner = this.width() - 6;
+        const wrapped = [];
+        for (const line of lines) {
+            if (line.length <= inner) {
+                wrapped.push(line);
+                continue;
+            }
+            let rest = line;
+            while (rest.length > inner) {
+                const cut = rest.lastIndexOf(' ', inner);
+                const at = cut > inner / 2 ? cut : inner;
+                wrapped.push(rest.slice(0, at));
+                rest = rest.slice(at).trimStart();
+            }
+            if (rest)
+                wrapped.push(rest);
+        }
+        const w = Math.min(this.width() - 2, Math.max(title.length, ...wrapped.map((l) => l.length), 20) + 4);
+        this.bar();
+        this.out(`${this.dim('╭' + '─'.repeat(w) + '╮')}`);
+        // Pad from the raw string length, then paint — ANSI codes must not count toward width.
+        const pad = (s, painted = s) => `${this.dim('│')}  ${painted}${' '.repeat(Math.max(0, w - s.length - 2))}${this.dim('│')}`;
+        this.out(pad(title, this.paint('1', title)));
+        for (const line of wrapped)
+            this.out(pad(line));
+        this.out(`${this.dim('╰' + '─'.repeat(w) + '╯')}`);
+    }
+    // ── spinner ────────────────────────────────────────────────────────────────
+    spinner(label) {
+        if (this.quiet) {
+            return { update: () => { }, succeed: () => { }, fail: () => { } };
+        }
+        if (!this.pretty) {
+            this.out(`… ${label}`);
+            return {
+                update: () => { },
+                succeed: (text) => this.ok(text || label),
+                fail: (text) => this.fail(text || label),
+            };
+        }
+        ensureCursorRestoredOnExit();
+        let current = label;
+        let i = 0;
+        process.stdout.write('\x1b[?25l');
+        const render = () => {
+            const frame = this.accent(FRAMES[i % FRAMES.length]);
+            process.stdout.write(`\r\x1b[K${frame}  ${current}`);
+            i += 1;
+        };
+        render();
+        const timer = setInterval(render, 80);
+        const finish = (glyphCode, glyph, text) => {
+            clearInterval(timer);
+            process.stdout.write(`\r\x1b[K`);
+            process.stdout.write('\x1b[?25h');
+            this.out(`${this.paint(glyphCode, glyph)}  ${text || current}`);
+        };
+        return {
+            update: (text) => {
+                current = text;
+            },
+            succeed: (text) => finish('32', '◇', text),
+            fail: (text) => finish('31', '✕', text),
+        };
+    }
+    // ── prompts ────────────────────────────────────────────────────────────────
+    async plainQuestion(prompt) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            return await rl.question(prompt);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    async select(label, options, initial = 0) {
+        if (!this.interactive)
+            throw new Error(`Cannot prompt for "${label}" in a non-interactive run.`);
+        if (!this.pretty) {
+            this.out(label);
+            options.forEach((o, idx) => this.out(`  ${idx + 1}) ${o.label}${o.hint ? ` — ${o.hint}` : ''}`));
+            for (;;) {
+                const answer = (await this.plainQuestion(`Choose 1-${options.length} (${initial + 1}): `)).trim();
+                if (!answer)
+                    return options[initial].value;
+                const n = Number(answer);
+                if (Number.isInteger(n) && n >= 1 && n <= options.length)
+                    return options[n - 1].value;
+            }
+        }
+        ensureCursorRestoredOnExit();
+        let index = initial;
+        const height = options.length + 2;
+        const render = (first) => {
+            if (!first)
+                process.stdout.write(`\x1b[${height}A`);
+            process.stdout.write('\x1b[J');
+            process.stdout.write(`${this.accent('◆')}  ${this.paint('1', label)}\n`);
+            options.forEach((o, idx) => {
+                const active = idx === index;
+                const dot = active ? this.accent('●') : this.dim('○');
+                const text = active ? o.label : this.dim(o.label);
+                const hint = o.hint && active ? `  ${this.dim(o.hint)}` : '';
+                process.stdout.write(`${this.dim('│')}  ${dot} ${text}${hint}\n`);
+            });
+            process.stdout.write(`${this.dim('└')}  ${this.dim('↑↓ move · enter select')}\n`);
+        };
+        process.stdout.write('\x1b[?25l');
+        render(true);
+        const value = await new Promise((resolve) => {
+            const stdin = process.stdin;
+            stdin.setRawMode?.(true);
+            stdin.resume();
+            const onData = (chunk) => {
+                const key = chunk.toString('utf8');
+                if (key === '\x03') {
+                    cleanup();
+                    process.stdout.write('\x1b[?25h\n');
+                    process.exit(130);
+                }
+                if (key === '\x1b[A' || key === 'k') {
+                    index = (index - 1 + options.length) % options.length;
+                    render(false);
+                }
+                else if (key === '\x1b[B' || key === 'j') {
+                    index = (index + 1) % options.length;
+                    render(false);
+                }
+                else if (key === '\r' || key === '\n') {
+                    cleanup();
+                    resolve(options[index].value);
+                }
+            };
+            const cleanup = () => {
+                stdin.off('data', onData);
+                stdin.setRawMode?.(false);
+                stdin.pause();
+            };
+            stdin.on('data', onData);
+        });
+        // Collapse the block to one settled line.
+        process.stdout.write(`\x1b[${height}A\x1b[J`);
+        process.stdout.write('\x1b[?25h');
+        const chosen = options.find((o) => o.value === value);
+        this.out(`${this.paint('32', '◇')}  ${label} ${this.dim('·')} ${chosen.label}`);
+        return value;
+    }
+    async text(label, opts = {}) {
+        if (!this.interactive)
+            throw new Error(`Cannot prompt for "${label}" in a non-interactive run.`);
+        if (!this.pretty) {
+            for (;;) {
+                const answer = (await this.plainQuestion(`${label}${opts.placeholder ? ` (${opts.placeholder})` : ''}: `)).trim();
+                const problem = opts.validate?.(answer);
+                if (!problem)
+                    return answer;
+                this.io.stderr(`error ${problem}`);
+            }
+        }
+        for (;;) {
+            process.stdout.write(`${this.accent('◆')}  ${this.paint('1', label)}\n`);
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            let answer;
+            try {
+                answer = (await rl.question(`${this.dim('│')}  ${this.dim('›')} `)).trim();
+            }
+            finally {
+                rl.close();
+            }
+            const problem = opts.validate?.(answer);
+            const promptVisibleLength = 5 + answer.length;
+            const lines = 1 + Math.max(1, Math.ceil(promptVisibleLength / (process.stdout.columns || 80)));
+            process.stdout.write(`\x1b[${lines}A\x1b[J`);
+            if (problem) {
+                this.out(`${this.paint('31', '✕')}  ${label} ${this.dim('·')} ${problem}`);
+                continue;
+            }
+            this.out(`${this.paint('32', '◇')}  ${label} ${this.dim('·')} ${opts.redactAs || answer || this.dim('(empty)')}`);
+            return answer;
+        }
+    }
+    async confirm(label, initial = true) {
+        if (!this.interactive)
+            return initial;
+        const suffix = initial ? 'Y/n' : 'y/N';
+        if (!this.pretty) {
+            const answer = (await this.plainQuestion(`${label} [${suffix}]: `)).trim().toLowerCase();
+            if (!answer)
+                return initial;
+            return answer.startsWith('y');
+        }
+        const value = await this.select(label, initial
+            ? [
+                { value: 'yes', label: 'Yes' },
+                { value: 'no', label: 'No' },
+            ]
+            : [
+                { value: 'no', label: 'No' },
+                { value: 'yes', label: 'Yes' },
+            ]);
+        return value === 'yes';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sella-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Sella onboarding CLI — install Sella into your agent clients, pair, verify, fund, publish. (`npx sella-cli init`)",
   "license": "MIT",
   "homepage": "https://sella.network",
@@ -12,7 +12,8 @@
   "engines": { "node": ">=18" },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "node dist/postinstall.js || exit 0"
   },
   "devDependencies": {
     "typescript": "^5"