@bytevion/cli 0.3.0 → 0.4.0

package/dist/commands/providers/add.js

@@ -106,16 +106,24 @@ class ProvidersAdd extends base_1.BaseCommand {
                     message: 'Model id to use in your tools',
                     options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
                 });
-                await ui.note(alias, 'Model id (use this everywhere)');
+                // Enable the chosen model so the gateway can serve it immediately.
+                const picked = models.find((m) => m.byte_alias === alias);
+                if (picked?.id)
+                    await api.modelEnable(picked.id).catch(() => undefined);
+                await ui.note(`${alias}\n\n${ui.theme.muted('Enabled and ready — use this id in your tools.')}`, 'Model id');
             }
             return res;
         }
         const res = await api.providersAdd(body);
+        // Enable the first imported model so the gateway is usable right away.
+        const firstModel = (res.fetch_result?.models ?? res.models ?? [])[0];
+        if (firstModel?.id)
+            await api.modelEnable(firstModel.id).catch(() => undefined);
         if (this.jsonEnabled())
             return res;
         const id = res.id ?? res.connection?.id;
         const imported = res.fetch_result?.imported ?? res.imported ?? 0;
-        this.log(`Provider connection added (id ${id}). Models imported: ${imported}.`);
+        this.log(`Provider connection added (id ${id}). Models imported: ${imported}.${firstModel?.byte_alias ? ` Enabled ${firstModel.byte_alias}.` : ''}`);
         return res;
     }
 }

package/dist/commands/run.js

@@ -9,7 +9,7 @@ class Run extends base_1.BaseCommand {
         prompt: core_1.Args.string({ description: 'The prompt to send', required: true }),
     };
     static flags = {
-        model: core_1.Flags.string({ description: 'Model or Byte alias', default: 'byte-default' }),
+        model: core_1.Flags.string({ description: 'Model or Byte alias (default: auto — routes to your enabled model)', default: 'auto' }),
         'max-tokens': core_1.Flags.integer({ description: 'Maximum output tokens' }),
     };
     async run() {

package/dist/commands/setup.d.ts

@@ -14,6 +14,7 @@ export default class Setup extends BaseCommand {
         connect: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<unknown>;
+    private buildWizardPorts;
     private connectProvider;
     private runNonInteractive;
 }

package/dist/commands/setup.js

@@ -66,6 +66,35 @@ class Setup extends base_1.BaseCommand {
         if (this.jsonEnabled() || !(0, tty_1.interactive)()) {
             return this.runNonInteractive(flags, profile, base);
         }
+        // Full-screen Ink wizard when the terminal supports it. Any failure inside the island
+        // returns {status:'fallback'} and we drop through to the clack flow below — no regression.
+        const tui = require('../lib/tui');
+        if (tui.useInk({ json: this.jsonEnabled() })) {
+            const ports = this.buildWizardPorts(flags, profile, base);
+            const res = await tui.renderWizardIsland({
+                plainColor: Boolean(process.env.NO_COLOR),
+                ascii: tui.computeAscii(),
+                version: this.config.version,
+                initial: { signedIn: Boolean((0, credentials_1.getToken)(profile)), email: undefined, byteKey: (0, credentials_1.getByteKey)(profile) },
+                ports,
+                providerPresets: providers_1.PROVIDER_PRESETS,
+                presetCards: presets_1.PRESET_CARDS,
+            });
+            if (res.status === 'cancelled')
+                return this.exit(130);
+            if (res.status === 'done') {
+                if (res.summary.connect) {
+                    await this.config.runCommand('integrate', [
+                        res.summary.connect,
+                        '--write',
+                        '--yes',
+                        ...(res.summary.model ? ['--model', res.summary.model] : []),
+                    ]);
+                }
+                return res.summary;
+            }
+            // status === 'fallback' → continue to the clack flow.
+        }
         await ui.intro(ui.banner());
         // 1) Sign in
         let token = (0, credentials_1.getToken)(profile);
@@ -150,6 +179,63 @@ class Setup extends base_1.BaseCommand {
         await ui.outro(`${ui.theme.ok('Setup complete.')}  Next: ${tips.join(' · ')}`);
         return { status: 'setup_complete', profile, model: provider.alias, provider: provider.status, preset };
     }
+    // Adapts the existing auth + API surface into the WizardPorts the Ink island calls. Every port
+    // wraps a call the clack flow already uses, so both paths hit identical backend behavior.
+    buildWizardPorts(flags, profile, base) {
+        const api = this.api(flags);
+        return {
+            signIn: async () => {
+                const r = await (0, auth_1.deviceLogin)({ baseUrl: base, profile });
+                return { email: r.email };
+            },
+            listProviders: async () => {
+                const existing = await api.providersList().catch(() => ({ connections: [] }));
+                return existing.connections ?? (Array.isArray(existing) ? existing : []);
+            },
+            connectProvider: async (a) => {
+                const res = await api.providersAdd({
+                    api_key: a.apiKey,
+                    gateway_mode: flags.mode || a.mode,
+                    base_url: a.baseUrl,
+                    auto_fetch: true,
+                });
+                const fetchResult = res.fetch_result ?? {};
+                const models = res.models ?? fetchResult.models ?? [];
+                const connId = res.id ?? res.connection?.id;
+                const failed = fetchResult.status === 'error' || Boolean(res.fetch_error) || Boolean(fetchResult.last_error);
+                const status = failed && !models.length ? 'saved' : 'connected';
+                return {
+                    status,
+                    models,
+                    connId,
+                    error: failed ? String(fetchResult.last_error || res.fetch_error || 'Provider models could not be loaded.') : undefined,
+                };
+            },
+            rotateAndTest: async (connId, apiKey) => {
+                try {
+                    await api.providersRotate(connId, apiKey);
+                    const test = await api.providersTest(connId);
+                    const models = test.models ?? [];
+                    return { models, error: models.length ? undefined : 'No models returned.' };
+                }
+                catch (err) {
+                    return { models: [], error: err?.message ?? String(err) };
+                }
+            },
+            enableModel: async (id) => {
+                await api.modelEnable(id).catch(() => undefined);
+            },
+            createByteKey: async (name, preset) => {
+                const res = await api.keysCreate({ name: name || 'cli', preset });
+                const key = String(res.key);
+                (0, credentials_1.setByteKey)(profile, key);
+                return { key };
+            },
+            applyPreset: async (preset) => {
+                await api.optPatch({ default_mode: preset }).catch(() => undefined);
+            },
+        };
+    }
     async connectProvider(api, flags) {
         const providerId = await ui.select({
             message: 'Which provider?',
@@ -220,6 +306,11 @@ class Setup extends base_1.BaseCommand {
                 message: 'Default model',
                 options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
             });
+            // Enable the chosen model so the gateway can route to it right away. Imported models
+            // start disabled — without this the first `byte run` would hit BYTE_ALIAS_NOT_CONFIGURED.
+            const picked = models.find((m) => m.byte_alias === alias);
+            if (picked?.id)
+                await api.modelEnable(picked.id).catch(() => undefined);
             return { alias, status: 'connected' };
         }
         return { status: 'saved' };
@@ -242,7 +333,11 @@ class Setup extends base_1.BaseCommand {
             const res = await api.providersAdd({ api_key: key, gateway_mode: mode, base_url: baseUrl, auto_fetch: true });
             const fetchResult = res.fetch_result ?? {};
             imported = fetchResult.imported ?? res.imported ?? 0;
-            chosenAlias = res.models?.[0]?.byte_alias;
+            const firstModel = res.models?.[0];
+            chosenAlias = firstModel?.byte_alias;
+            // Enable the first model so the gateway works immediately (imported models start disabled).
+            if (firstModel?.id)
+                await api.modelEnable(firstModel.id).catch(() => undefined);
             if (fetchResult.status === 'error' || res.fetch_error) {
                 providerStatus = 'saved';
                 providerError = String(fetchResult.last_error || res.fetch_error);

package/dist/hooks/init/home.js

@@ -37,6 +37,7 @@ const api_1 = require("../../lib/api");
 const config_1 = require("../../lib/config");
 const credentials_1 = require("../../lib/credentials");
 const home_1 = require("../../lib/home");
+const output_1 = require("../../lib/output");
 const tty_1 = require("../../lib/tty");
 const ui = __importStar(require("../../lib/ui"));
 // oclif runs init hooks before it would print help. Bare `byte` (no command) in a real
@@ -64,6 +65,29 @@ const hook = async function (opts) {
         if (loaded)
             data = { ...data, ...loaded };
     }
+    // Full-screen Ink home dashboard + quick-actions menu, when the terminal supports it. Any
+    // failure inside the island returns {status:'fallback'} and we drop straight through to the
+    // existing clack dashboard below — nothing regresses.
+    const tui = require('../../lib/tui');
+    if (tui.useInk()) {
+        const res = await tui.renderHomeIsland({
+            signedIn,
+            data: { ...data, gateway: data.gateway ?? 'unknown', byteKeyMasked: (0, output_1.maskKey)(byteKey) },
+            plainColor: Boolean(process.env.NO_COLOR),
+            ascii: tui.computeAscii(),
+            version: this.config.version,
+        });
+        if (res.status === 'exit') {
+            await this.exit(0);
+            return;
+        }
+        if (res.status === 'action') {
+            await this.config.runCommand(res.commandId, res.argv);
+            await this.exit(0);
+            return;
+        }
+        // status === 'fallback' → continue to the clack dashboard.
+    }
     this.log(`\n${(0, home_1.renderHome)(data, signedIn)}\n`);
     const choice = await ui.select({
         message: 'What would you like to do?',

package/dist/lib/api.d.ts

@@ -22,6 +22,7 @@ export declare class ByteApi {
     providersAdd(body: Record<string, unknown>): Promise<any>;
     providersRotate(id: number, apiKey: string): Promise<any>;
     providersTest(id: number): Promise<any>;
+    modelEnable(id: number): Promise<any>;
     optShow(): Promise<any>;
     optPatch(body: Record<string, unknown>): Promise<any>;
     usage(granularity: string): Promise<any>;

package/dist/lib/api.js

@@ -94,6 +94,12 @@ class ByteApi {
     providersTest(id) {
         return this.request('POST', `/api/v1/model-connections/${id}/fetch-models`, { body: {} });
     }
+    // Enable an imported provider model so the gateway can route to it. Imported models
+    // arrive disabled; without enabling at least one, the gateway returns
+    // BYTE_ALIAS_NOT_CONFIGURED. Setup/providers-add call this on the model the user picks.
+    modelEnable(id) {
+        return this.request('PATCH', `/api/v1/models/${id}`, { body: { enabled: true } });
+    }
     // --- optimizations ---
     optShow() {
         return this.request('GET', '/api/v1/optimizations');

package/dist/lib/tui.d.ts

@@ -0,0 +1,105 @@
+export interface HomeData {
+    email?: string;
+    org?: string;
+    providers?: number;
+    models?: number;
+    byteKeyMasked?: string;
+    gateway: 'healthy' | 'down' | 'unknown';
+    savingsSeries: number[];
+    savedTotal: number;
+    tokensTotal: number;
+    hitRate?: number;
+}
+export interface HomeIslandProps {
+    signedIn: boolean;
+    data: HomeData;
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+}
+export type HomeResult = {
+    status: 'fallback';
+} | {
+    status: 'exit';
+} | {
+    status: 'action';
+    commandId: string;
+    argv: string[];
+};
+export interface WizardPorts {
+    signIn(): Promise<{
+        email?: string;
+    }>;
+    listProviders(): Promise<any[]>;
+    connectProvider(a: {
+        id: string;
+        label: string;
+        baseUrl?: string;
+        apiKey: string;
+        mode: string;
+    }): Promise<{
+        status: 'connected' | 'saved' | 'failed';
+        models: any[];
+        connId?: number;
+        error?: string;
+    }>;
+    rotateAndTest(connId: number, apiKey: string): Promise<{
+        models: any[];
+        error?: string;
+    }>;
+    enableModel(id: number): Promise<void>;
+    createByteKey(name: string, preset: string): Promise<{
+        key: string;
+    }>;
+    applyPreset(preset: string): Promise<void>;
+}
+export interface ProviderPresetDTO {
+    id: string;
+    label: string;
+    base_url: string;
+    gateway_mode: string;
+    advanced?: boolean;
+    custom?: boolean;
+    note?: string;
+}
+export interface PresetCardDTO {
+    value: string;
+    label: string;
+    hint: string;
+    blurb: string;
+}
+export interface WizardIslandProps {
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+    initial: {
+        signedIn: boolean;
+        email?: string;
+        byteKey?: string;
+    };
+    ports: WizardPorts;
+    providerPresets: ProviderPresetDTO[];
+    presetCards: PresetCardDTO[];
+}
+export interface WizardSummary {
+    profile?: string;
+    model?: string;
+    provider: 'connected' | 'saved' | 'skipped' | 'failed';
+    preset: string;
+    byteKeyCreated: boolean;
+    connect?: string;
+}
+export type WizardResult = {
+    status: 'fallback';
+} | {
+    status: 'cancelled';
+} | {
+    status: 'done';
+    summary: WizardSummary;
+};
+export declare function useInk(opts?: {
+    json?: boolean;
+}): boolean;
+export declare function computeAscii(): boolean;
+export declare function renderHomeIsland(props: HomeIslandProps): Promise<HomeResult>;
+export declare function renderWizardIsland(props: WizardIslandProps): Promise<WizardResult>;

package/dist/lib/tui.gate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/tui.gate.test.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const tui_1 = require("./tui");
+// Snapshot the process knobs useInk reads so each case can set a clean world and restore it.
+const saved = {
+    stdinTTY: process.stdin.isTTY,
+    stdoutTTY: process.stdout.isTTY,
+    columns: process.stdout.columns,
+    env: { ...process.env },
+};
+function setWorld(opts) {
+    Object.defineProperty(process.stdin, 'isTTY', { value: opts.stdin ?? true, configurable: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: opts.stdout ?? true, configurable: true });
+    Object.defineProperty(process.stdout, 'columns', { value: opts.columns ?? 120, configurable: true });
+    // Clear the opt-out / CI / color env that useInk inspects, then apply overrides.
+    for (const k of ['NO_COLOR', 'CI', 'BYTE_PLAIN', 'BYTE_TUI', 'BYTE_NO_MENU'])
+        delete process.env[k];
+    for (const [k, v] of Object.entries(opts.env ?? {})) {
+        if (v === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = v;
+    }
+}
+(0, node_test_1.afterEach)(() => {
+    Object.defineProperty(process.stdin, 'isTTY', { value: saved.stdinTTY, configurable: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: saved.stdoutTTY, configurable: true });
+    Object.defineProperty(process.stdout, 'columns', { value: saved.columns, configurable: true });
+    for (const k of Object.keys(process.env))
+        if (!(k in saved.env))
+            delete process.env[k];
+    Object.assign(process.env, saved.env);
+});
+(0, node_test_1.test)('useInk true on a wide, color-capable TTY with no opt-out', () => {
+    setWorld({ stdin: true, stdout: true, columns: 120 });
+    strict_1.default.equal((0, tui_1.useInk)(), true);
+});
+(0, node_test_1.test)('useInk false when stdout is not a TTY (piped)', () => {
+    setWorld({ stdout: false });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false when stdin is not a TTY', () => {
+    setWorld({ stdin: false });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false under CI', () => {
+    setWorld({ env: { CI: '1' } });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false under NO_COLOR', () => {
+    setWorld({ env: { NO_COLOR: '1' } });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false when the window is narrower than 80 columns', () => {
+    setWorld({ columns: 70 });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false with BYTE_PLAIN=1, BYTE_TUI=0, or BYTE_NO_MENU=1', () => {
+    setWorld({ env: { BYTE_PLAIN: '1' } });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+    setWorld({ env: { BYTE_TUI: '0' } });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+    setWorld({ env: { BYTE_NO_MENU: '1' } });
+    strict_1.default.equal((0, tui_1.useInk)(), false);
+});
+(0, node_test_1.test)('useInk false when the JSON flag is set even on a good TTY', () => {
+    setWorld({});
+    strict_1.default.equal((0, tui_1.useInk)({ json: true }), false);
+});
+(0, node_test_1.test)('computeAscii true on bare win32 (no Windows Terminal / WSL)', () => {
+    const savedPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+    Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+    delete process.env.WT_SESSION;
+    delete process.env.WSL_DISTRO_NAME;
+    delete process.env.TERM;
+    strict_1.default.equal((0, tui_1.computeAscii)(), true);
+    // Windows Terminal sets WT_SESSION → unicode is safe.
+    process.env.WT_SESSION = '1';
+    strict_1.default.equal((0, tui_1.computeAscii)(), false);
+    delete process.env.WT_SESSION;
+    Object.defineProperty(process, 'platform', savedPlatform);
+});
+(0, node_test_1.test)('computeAscii true on a dumb terminal regardless of platform', () => {
+    const savedPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+    Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+    process.env.TERM = 'dumb';
+    strict_1.default.equal((0, tui_1.computeAscii)(), true);
+    delete process.env.TERM;
+    strict_1.default.equal((0, tui_1.computeAscii)(), false);
+    Object.defineProperty(process, 'platform', savedPlatform);
+});

package/dist/lib/tui.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInk = useInk;
+exports.computeAscii = computeAscii;
+exports.renderHomeIsland = renderHomeIsland;
+exports.renderWizardIsland = renderWizardIsland;
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+// CJS→ESM bridge for the Ink island. This file stays under src/lib (CommonJS) and is the ONLY
+// thing the commands touch; the island itself lives under src/tui and is compiled separately to
+// ESM (dist/tui). Like src/lib/ui.ts, a plain import() would be down-levelled to require() and
+// blow up on ESM-only Ink, so we hide it behind `new Function`. Every entry point is
+// fallback-first: ANY failure resolves to {status:'fallback'} and the caller drops to clack.
+const importESM = new Function('s', 'return import(s)');
+// Resolve the island entry as an absolute file:// URL off this module's location. Both the
+// CJS bridge (dist/lib/tui.js) and the island (dist/tui/index.js) live under dist/, so step up
+// one level. pathToFileURL is MANDATORY on Windows — a bare path makes dynamic import throw
+// ERR_UNSUPPORTED_ESM_URL_SCHEME.
+function islandUrl() {
+    return (0, node_url_1.pathToFileURL)(node_path_1.default.join(__dirname, '..', 'tui', 'index.js')).href;
+}
+// Gate: the Ink UI only takes over when we have a real, wide-enough, color-capable TTY on both
+// ends and nobody opted out. Any miss (pipe, CI, narrow window, NO_COLOR, BYTE_PLAIN, the JSON
+// flag) returns false and the caller stays on the existing clack path. Mirrors lib/tty.ts.
+function useInk(opts) {
+    return (Boolean(process.stdin.isTTY) &&
+        Boolean(process.stdout.isTTY) &&
+        (process.stdout.columns ?? 0) >= 80 &&
+        !process.env.NO_COLOR &&
+        !process.env.CI &&
+        process.env.BYTE_PLAIN !== '1' &&
+        process.env.BYTE_TUI !== '0' &&
+        process.env.BYTE_NO_MENU !== '1' &&
+        !opts?.json);
+}
+// Drop to 7-bit glyphs on legacy Windows consoles (conhost without Windows Terminal / WSL) and
+// dumb terminals, where unicode block glyphs render as mojibake.
+function computeAscii() {
+    return ((process.platform === 'win32' && !process.env.WT_SESSION && !process.env.WSL_DISTRO_NAME) ||
+        process.env.TERM === 'dumb');
+}
+async function renderHomeIsland(props) {
+    try {
+        const mod = await importESM(islandUrl());
+        return (await mod.renderHome(props));
+    }
+    catch {
+        return { status: 'fallback' };
+    }
+}
+async function renderWizardIsland(props) {
+    try {
+        const mod = await importESM(islandUrl());
+        return (await mod.renderWizard(props));
+    }
+    catch {
+        return { status: 'fallback' };
+    }
+}

package/dist/tui/__tests__/home.render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/__tests__/home.render.test.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { render } from 'ink-testing-library';
+import { Home } from '../components/Home.js';
+// Strip ANSI so assertions match the visible text regardless of the per-char gradient coloring
+// (the gradient inserts color codes between letters, so "BYTE" is only contiguous once stripped).
+const ANSI = /\[[0-9;]*m/g;
+const plain = (s) => (s ?? '').replace(ANSI, '');
+const data = {
+    email: 'founder@byte.co',
+    org: 'Bytevion',
+    providers: 2,
+    models: 14,
+    byteKeyMasked: 'byte_sk_live_abcd...wxyz',
+    gateway: 'healthy',
+    savingsSeries: [1, 3, 2, 6, 4, 8, 5],
+    savedTotal: 12.5,
+    tokensTotal: 1_200_000,
+    hitRate: 0.42,
+};
+test('Home (unicode) renders brand, identity, masked key, gateway dot, and sparkline', () => {
+    const { lastFrame, unmount } = render(_jsx(Home, { signedIn: true, data: data, ascii: false, plainColor: false, version: "0.3.0", onDone: () => { } }));
+    const out = plain(lastFrame());
+    unmount();
+    assert.match(out, /BYTE/); // gradient wordmark (contiguous after stripping ANSI)
+    assert.match(out, /optimization gateway/);
+    assert.match(out, /founder@byte\.co/);
+    assert.match(out, /Bytevion/);
+    assert.match(out, /2 connected/);
+    assert.match(out, /14 models/);
+    assert.match(out, /byte_sk_live_abcd\.\.\.wxyz/);
+    assert.ok(out.includes('●'), 'gateway dot glyph present');
+    assert.match(out, /healthy/);
+    // unicode block sparkline ramp
+    assert.ok(/[▁▂▃▄▅▆▇█]/.test(out), 'unicode sparkline present');
+    assert.match(out, /saved/);
+    assert.match(out, /Set up Byte/); // quick-actions menu
+});
+test('Home (ascii) swaps glyphs: classic dot + ascii sparkline, still shows the key', () => {
+    const { lastFrame, unmount } = render(_jsx(Home, { signedIn: true, data: data, ascii: true, plainColor: true, version: "0.3.0", onDone: () => { } }));
+    const out = plain(lastFrame());
+    unmount();
+    assert.match(out, /BYTE/);
+    assert.match(out, /byte_sk_live_abcd\.\.\.wxyz/);
+    assert.match(out, /healthy/);
+    // ascii gateway dot + ascii sparkline ramp; no unicode block glyphs
+    assert.ok(out.includes('[*]'), 'ascii gateway glyph present');
+    assert.ok(!/[▁▂▃▄▅▆▇█●]/.test(out), 'no unicode glyphs in ascii mode');
+    assert.ok(/[.:\-=+*#]/.test(out), 'ascii sparkline ramp present');
+});
+test('Home signed-out shows "not signed in" and a Sign in action', () => {
+    const signedOut = { gateway: 'unknown', savingsSeries: [], savedTotal: 0, tokensTotal: 0 };
+    const { lastFrame, unmount } = render(_jsx(Home, { signedIn: false, data: signedOut, ascii: false, plainColor: false, version: "0.3.0", onDone: () => { } }));
+    const out = plain(lastFrame());
+    unmount();
+    assert.match(out, /not signed in/);
+    assert.match(out, /Sign in/);
+});

package/dist/tui/__tests__/state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/__tests__/state.test.js

@@ -0,0 +1,88 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { initialState, reducer, selectSummary } from '../state.js';
+const base = (over = {}) => ({ ...initialState({ signedIn: false }), ...over });
+test('initialState seeds maximum preset and pending provider', () => {
+    const s = initialState({ signedIn: true, email: 'a@b.co', byteKey: 'byte_sk_live_x' });
+    assert.equal(s.step, 'welcome');
+    assert.equal(s.signedIn, true);
+    assert.equal(s.email, 'a@b.co');
+    assert.equal(s.preset, 'maximum');
+    assert.equal(s.providerStatus, 'pending');
+    assert.equal(s.byteKey, 'byte_sk_live_x');
+    assert.equal(s.byteKeyRevealed, false);
+});
+test('happy path advances welcome→signin→provider→model→key→preset→integrate→done', () => {
+    let s = base();
+    s = reducer(s, { type: 'GOTO', step: 'signin' });
+    assert.equal(s.step, 'signin');
+    s = reducer(s, { type: 'SIGNED_IN', email: 'me@byte.co' });
+    assert.equal(s.step, 'provider');
+    assert.equal(s.signedIn, true);
+    assert.equal(s.email, 'me@byte.co');
+    s = reducer(s, { type: 'PICK_PROVIDER', id: 'openai', baseUrl: undefined });
+    assert.equal(s.providerChoice, 'openai');
+    s = reducer(s, { type: 'PROVIDER_RESULT', status: 'connected', models: [{ id: 1, byte_alias: 'byte-gpt' }], connId: 7 });
+    assert.equal(s.step, 'model');
+    assert.equal(s.providerStatus, 'connected');
+    assert.equal(s.connId, 7);
+    assert.equal(s.models.length, 1);
+    s = reducer(s, { type: 'PICK_MODEL', model: 'byte-gpt' });
+    assert.equal(s.step, 'key');
+    assert.equal(s.model, 'byte-gpt');
+    s = reducer(s, { type: 'KEY_CREATED', key: 'byte_sk_live_abc' });
+    assert.equal(s.byteKey, 'byte_sk_live_abc');
+    assert.equal(s.byteKeyRevealed, true);
+    // KEY_CREATED reveals but does not auto-advance; NEXT moves on.
+    s = reducer(s, { type: 'NEXT' });
+    assert.equal(s.step, 'preset');
+    s = reducer(s, { type: 'PICK_PRESET', preset: 'balanced' });
+    assert.equal(s.step, 'integrate');
+    assert.equal(s.preset, 'balanced');
+    s = reducer(s, { type: 'PICK_CONNECT', connect: 'opencode' });
+    assert.equal(s.step, 'done');
+    const summary = selectSummary(s);
+    assert.equal(summary.provider, 'connected');
+    assert.equal(summary.model, 'byte-gpt');
+    assert.equal(summary.preset, 'balanced');
+    assert.equal(summary.byteKeyCreated, true);
+    assert.equal(summary.connect, 'opencode');
+});
+test('PROVIDER_RESULT connected without models skips the model step', () => {
+    const s = reducer(base({ step: 'provider' }), { type: 'PROVIDER_RESULT', status: 'connected', models: [], connId: 3 });
+    assert.equal(s.step, 'key');
+});
+test('PROVIDER_RESULT saved routes to key and summary reports saved', () => {
+    const s = reducer(base({ step: 'provider' }), { type: 'PROVIDER_RESULT', status: 'saved', models: [], connId: 9 });
+    assert.equal(s.step, 'key');
+    assert.equal(s.providerStatus, 'saved');
+    assert.equal(selectSummary(s).provider, 'saved');
+});
+test('ERROR is non-fatal: keeps the step, drops busy, records message', () => {
+    const s = reducer(base({ step: 'provider', busy: true }), { type: 'ERROR', from: 'provider', message: 'bad key' });
+    assert.equal(s.step, 'provider');
+    assert.equal(s.busy, false);
+    assert.deepEqual(s.error, { from: 'provider', message: 'bad key' });
+    // a following NEXT clears the error
+    const cleared = reducer(s, { type: 'CLEAR_ERROR' });
+    assert.equal(cleared.error, undefined);
+});
+test('PROVIDER_RETRY returns to the provider step with a pending status', () => {
+    const errored = reducer(base({ step: 'provider' }), { type: 'ERROR', from: 'provider', message: 'unreachable' });
+    const retry = reducer(errored, { type: 'PROVIDER_RETRY' });
+    assert.equal(retry.step, 'provider');
+    assert.equal(retry.providerStatus, 'pending');
+    assert.equal(retry.error, undefined);
+});
+test('PROVIDER_SKIP marks skipped and summary downgrades pending→skipped', () => {
+    const s = reducer(base({ step: 'provider' }), { type: 'PROVIDER_SKIP' });
+    assert.equal(s.providerStatus, 'skipped');
+    assert.equal(s.step, 'key');
+    assert.equal(selectSummary(s).provider, 'skipped');
+    // a never-touched provider (still pending) also reports as skipped in the summary
+    assert.equal(selectSummary(base()).provider, 'skipped');
+});
+test('selectSummary drops a "skip" connect choice', () => {
+    const s = reducer(base({ step: 'integrate' }), { type: 'PICK_CONNECT', connect: 'skip' });
+    assert.equal(selectSummary(s).connect, undefined);
+});

package/dist/tui/components/App.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { WizardIslandProps, WizardResult } from '../contract.js';
+interface AppProps extends WizardIslandProps {
+    onDone: (result: WizardResult) => void;
+}
+export declare function App({ plainColor, ascii, version, initial, ports, providerPresets, presetCards, onDone, }: AppProps): React.ReactElement;
+export {};