@bytevion/cli 0.4.1 → 0.5.0

package/dist/commands/sync.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const wiring_1 = require("../lib/wiring");
+class Sync extends base_1.BaseCommand {
+    static description = 'Re-apply your current Byte key/model to every wired coding agent (run after rotating a key or switching model).';
+    static examples = ['<%= config.bin %> sync', '<%= config.bin %> sync --model byte-2-deepseek-v4-flash'];
+    static flags = {
+        model: core_1.Flags.string({ description: 'Model id (byte alias) to wire (defaults to the last wired model)' }),
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompts' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Sync);
+        this.requireByteKey(flags);
+        const profile = this.profileFrom(flags);
+        const wiring = (0, wiring_1.getWiring)(profile);
+        const tools = wiring.tools || [];
+        if (!tools.length) {
+            if (!this.jsonEnabled())
+                this.log('No wired tools yet. Run `byte connect` first.');
+            return { synced: [] };
+        }
+        const model = flags.model || wiring.model;
+        if (flags.model)
+            (0, wiring_1.setSelectedModel)(profile, flags.model);
+        const synced = [];
+        for (const key of tools) {
+            const argv = [key, '--write', '--yes', ...(model ? ['--model', model] : [])];
+            // eslint-disable-next-line no-await-in-loop
+            await this.config.runCommand('integrate', argv);
+            synced.push(key);
+        }
+        if (!this.jsonEnabled())
+            this.log(`Synced ${synced.length} tool(s): ${synced.join(', ')}.`);
+        return { synced, model };
+    }
+}
+exports.default = Sync;

package/dist/lib/api.d.ts

@@ -23,10 +23,17 @@ export declare class ByteApi {
     providersRotate(id: number, apiKey: string): Promise<any>;
     providersTest(id: number): Promise<any>;
     modelEnable(id: number): Promise<any>;
+    modelsList(): Promise<any>;
+    modelCompare(id: number, on: boolean): Promise<any>;
+    mcpServers(): Promise<any>;
+    mcpAdd(body: Record<string, unknown>): Promise<any>;
+    mcpRemove(id: number): Promise<any>;
+    mcpTest(id: number): Promise<any>;
     optShow(): Promise<any>;
     optPatch(body: Record<string, unknown>): Promise<any>;
     usage(granularity: string): Promise<any>;
     dashboard(): Promise<any>;
+    requests(): Promise<any>;
     cacheStats(): Promise<any>;
     costs(): Promise<any>;
     health(): Promise<any>;

package/dist/lib/api.js

@@ -100,6 +100,27 @@ class ByteApi {
     modelEnable(id) {
         return this.request('PATCH', `/api/v1/models/${id}`, { body: { enabled: true } });
     }
+    modelsList() {
+        return this.request('GET', '/api/v1/models');
+    }
+    // Toggle direct-vs-Byte comparison eligibility. Two priced models with compare on
+    // form the auto-pair `byte compare` needs; one is enough for `byte compare --model <alias>`.
+    modelCompare(id, on) {
+        return this.request('PATCH', `/api/v1/models/${id}`, { body: { compare_enabled: on } });
+    }
+    // --- MCP servers (Byte-hosted) ---
+    mcpServers() {
+        return this.request('GET', '/api/v1/mcp/servers');
+    }
+    mcpAdd(body) {
+        return this.request('POST', '/api/v1/mcp/servers', { body });
+    }
+    mcpRemove(id) {
+        return this.request('DELETE', `/api/v1/mcp/servers/${id}`);
+    }
+    mcpTest(id) {
+        return this.request('POST', `/api/v1/mcp/servers/${id}/test`, { body: {} });
+    }
     // --- optimizations ---
     optShow() {
         return this.request('GET', '/api/v1/optimizations');
@@ -114,6 +135,9 @@ class ByteApi {
     dashboard() {
         return this.request('GET', '/api/v1/dashboard/summary');
     }
+    requests() {
+        return this.request('GET', '/api/v1/requests');
+    }
     cacheStats() {
         return this.request('GET', '/api/v1/cache/stats');
     }

package/dist/lib/config-formats.d.ts

@@ -0,0 +1,3 @@
+export type SettingsFormat = 'json' | 'toml';
+export declare function parseConfig(format: SettingsFormat, text: string): any;
+export declare function stringifyConfig(format: SettingsFormat, value: any): string;

package/dist/lib/config-formats.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfig = parseConfig;
+exports.stringifyConfig = stringifyConfig;
+function parseConfig(format, text) {
+    if (format === 'toml')
+        return parseToml(text);
+    return text.trim() ? JSON.parse(text) : {};
+}
+function stringifyConfig(format, value) {
+    if (format === 'toml')
+        return stringifyToml(value);
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function parseTomlValue(raw) {
+    const v = raw.trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))
+        return v.slice(1, -1);
+    if (v === 'true')
+        return true;
+    if (v === 'false')
+        return false;
+    if (/^-?\d+$/.test(v))
+        return Number(v);
+    if (/^-?\d*\.\d+$/.test(v))
+        return Number(v);
+    if (v.startsWith('[') || v.startsWith('{'))
+        throw new Error('BYTE_TOML_UNSUPPORTED');
+    return v;
+}
+function parseToml(text) {
+    const root = {};
+    let current = root;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const section = trimmed.match(/^\[([^\]]+)\]$/);
+        if (section) {
+            current = root;
+            for (const part of section[1].split('.').map((p) => p.trim())) {
+                current[part] = current[part] && typeof current[part] === 'object' ? current[part] : {};
+                current = current[part];
+            }
+            continue;
+        }
+        const eq = trimmed.indexOf('=');
+        if (eq === -1)
+            throw new Error('BYTE_TOML_UNSUPPORTED');
+        current[trimmed.slice(0, eq).trim()] = parseTomlValue(trimmed.slice(eq + 1));
+    }
+    return root;
+}
+function formatTomlValue(value) {
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number')
+        return String(value);
+    return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function stringifyToml(obj) {
+    const scalars = [];
+    const tables = [];
+    const emitTable = (path, table) => {
+        const lines = [`[${path}]`];
+        const nested = [];
+        for (const [key, value] of Object.entries(table)) {
+            if (value && typeof value === 'object' && !Array.isArray(value))
+                nested.push([key, value]);
+            else
+                lines.push(`${key} = ${formatTomlValue(value)}`);
+        }
+        tables.push(lines.join('\n'));
+        for (const [key, value] of nested)
+            emitTable(`${path}.${key}`, value);
+    };
+    for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object' && !Array.isArray(value))
+            emitTable(key, value);
+        else
+            scalars.push(`${key} = ${formatTomlValue(value)}`);
+    }
+    const parts = [...scalars];
+    if (scalars.length && tables.length)
+        parts.push('');
+    parts.push(...tables);
+    return `${parts.join('\n')}\n`;
+}

package/dist/lib/detect.d.ts

@@ -0,0 +1,9 @@
+export interface DetectedTool {
+    key: string;
+    title: string;
+    installed: boolean;
+    reason: 'binary' | 'config' | 'both' | 'none';
+    canAutoWrite: boolean;
+    configPath?: string;
+}
+export declare function detectTools(): DetectedTool[];

package/dist/lib/detect.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTools = detectTools;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const integrations_1 = require("./integrations");
+// Per-tool detection hints: binaries we look for on PATH, and config dirs/files whose
+// presence also implies the tool is installed. Keys must match integrations.ts entries.
+const PROBES = {
+    opencode: { bins: ['opencode'], configs: [(0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'opencode')] },
+    'claude-code': { bins: ['claude'], configs: [(0, node_path_1.join)((0, node_os_1.homedir)(), '.claude')] },
+    codex: { bins: ['codex'], configs: [process.env.CODEX_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex')] },
+    cursor: { bins: ['cursor'], configs: [] },
+    cline: { bins: [], configs: [] },
+    aider: { bins: ['aider'], configs: [(0, node_path_1.join)((0, node_os_1.homedir)(), '.aider.conf.yml')] },
+    continue: { bins: ['cn'], configs: [(0, node_path_1.join)((0, node_os_1.homedir)(), '.continue')] },
+    zed: { bins: ['zed', 'zeditor'], configs: [(0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'zed')] },
+    goose: { bins: ['goose'], configs: [] },
+    'gemini-cli': { bins: ['gemini'], configs: [] },
+    'qwen-code': { bins: ['qwen'], configs: [] },
+};
+function exists(path) {
+    try {
+        return (0, node_fs_1.existsSync)(path);
+    }
+    catch {
+        return false;
+    }
+}
+function binaryOnPath(name) {
+    const dirs = (process.env.PATH || '').split(node_path_1.delimiter).filter(Boolean);
+    const exts = process.platform === 'win32' ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.PS1').split(';').filter(Boolean) : [''];
+    for (const dir of dirs) {
+        if (process.platform !== 'win32' && exists((0, node_path_1.join)(dir, name)))
+            return true;
+        for (const ext of exts) {
+            if (exists((0, node_path_1.join)(dir, name + ext)))
+                return true;
+        }
+    }
+    return false;
+}
+function hasWriter(key) {
+    const integ = (0, integrations_1.findIntegration)(key);
+    if (!integ)
+        return false;
+    try {
+        return Boolean(integ.build({ baseUrl: '', byteKey: '', modelAlias: '' }).settingsFile);
+    }
+    catch {
+        return false;
+    }
+}
+// Inspect the local machine for installed coding agents (PATH binaries + known config
+// dirs). Pure filesystem + env reads — no process spawning, sandbox-safe and fast.
+function detectTools() {
+    const known = new Set((0, integrations_1.listIntegrations)().map((i) => i.key));
+    const out = [];
+    for (const [key, probe] of Object.entries(PROBES)) {
+        if (!known.has(key))
+            continue;
+        const integ = (0, integrations_1.findIntegration)(key);
+        if (!integ)
+            continue;
+        const hasBin = probe.bins.some(binaryOnPath);
+        const cfgPath = probe.configs.find(exists);
+        const hasCfg = Boolean(cfgPath);
+        if (!hasBin && !hasCfg) {
+            out.push({ key, title: integ.title, installed: false, reason: 'none', canAutoWrite: hasWriter(key) });
+            continue;
+        }
+        out.push({
+            key,
+            title: integ.title,
+            installed: true,
+            reason: hasBin && hasCfg ? 'both' : hasBin ? 'binary' : 'config',
+            canAutoWrite: hasWriter(key),
+            configPath: cfgPath,
+        });
+    }
+    return out;
+}

package/dist/lib/friendly.js

@@ -33,6 +33,16 @@ function friendlyError(err) {
             why: 'The provider URL or key looks unreachable right now — your connection is still saved.',
             next: 'byte providers test',
         },
+        BYTE_AUTO_PAIR_INCOMPLETE: {
+            issue: 'Compare needs a baseline↔Byte model pair.',
+            why: 'No two priced models have comparison enabled yet, so there is nothing to compare against.',
+            next: 'byte providers compare --all',
+        },
+        BYTE_MODEL_COMPARE_DISABLED: {
+            issue: 'Comparison is turned off for this model.',
+            why: 'A model must have comparison enabled to run the direct-vs-Byte lanes.',
+            next: 'byte providers compare <alias>',
+        },
         BYTE_DEVICE_DENIED: {
             issue: 'Sign-in was declined in the browser.',
             why: 'The device approval was rejected or closed.',

package/dist/lib/integrations.d.ts

@@ -6,6 +6,7 @@ export interface IntegrationContext {
 }
 export interface SettingsFile {
     path: string;
+    format?: 'json' | 'toml';
     apply: (existing: any) => any;
 }
 export interface IntegrationResult {

package/dist/lib/integrations.js

@@ -4,6 +4,7 @@ exports.listIntegrations = listIntegrations;
 exports.findIntegration = findIntegration;
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const paths_1 = require("./paths");
 const openaiEnv = (ctx) => [
     ['OPENAI_BASE_URL', `${ctx.baseUrl}/v1`],
     ['OPENAI_API_KEY', ctx.byteKey],
@@ -39,8 +40,21 @@ const INTEGRATIONS = [
         title: 'Codex CLI',
         compat: 'openai',
         build: (ctx) => ({
-            env: openaiEnv(ctx),
-            instructions: ['Codex CLI uses OPENAI_BASE_URL + OPENAI_API_KEY (or ~/.codex/config.toml). Set the env vars below, then run codex.'],
+            env: [['BYTE_API_KEY', ctx.byteKey]],
+            instructions: [
+                `Wires the "byte" provider in ${(0, paths_1.codexConfigPath)()} (model: ${ctx.modelAlias}).`,
+                'Export BYTE_API_KEY (above) so Codex reads it via env_key.',
+            ],
+            settingsFile: {
+                path: (0, paths_1.codexConfigPath)(),
+                format: 'toml',
+                apply: (existing) => {
+                    const cfg = existing && typeof existing === 'object' ? existing : {};
+                    const providers = { ...(cfg.model_providers ?? {}) };
+                    providers.byte = { ...(providers.byte ?? {}), name: 'Byte', base_url: `${ctx.baseUrl}/v1`, wire_api: 'chat', env_key: 'BYTE_API_KEY' };
+                    return { ...cfg, model_provider: 'byte', model: ctx.modelAlias, model_providers: providers };
+                },
+            },
         }),
     },
     {
@@ -138,8 +152,23 @@ const INTEGRATIONS = [
         title: 'Zed',
         compat: 'openai',
         build: (ctx) => ({
-            env: [],
-            instructions: ['Zed → settings.json, add a custom LLM provider with:', `  "api_url": "${ctx.baseUrl}/v1"`, `  API key set via Zed’s key prompt; model ${ctx.modelAlias}`],
+            env: [['BYTE_API_KEY', ctx.byteKey]],
+            instructions: [
+                `Wires an OpenAI-compatible "byte" provider in ${(0, paths_1.zedSettingsPath)()} (model ${ctx.modelAlias}).`,
+                'Enter the BYTE_API_KEY (above) when Zed prompts for the provider key.',
+            ],
+            settingsFile: {
+                path: (0, paths_1.zedSettingsPath)(),
+                format: 'json',
+                apply: (existing) => {
+                    const cfg = existing && typeof existing === 'object' ? existing : {};
+                    const languageModels = { ...(cfg.language_models ?? {}) };
+                    const openaiCompatible = { ...(languageModels.openai_compatible ?? {}) };
+                    openaiCompatible.byte = { ...(openaiCompatible.byte ?? {}), api_url: `${ctx.baseUrl}/v1`, available_models: [{ name: ctx.modelAlias }] };
+                    languageModels.openai_compatible = openaiCompatible;
+                    return { ...cfg, language_models: languageModels };
+                },
+            },
         }),
     },
     {

package/dist/lib/paths.d.ts

@@ -1,3 +1,5 @@
 export declare function byteDir(): string;
 export declare function configPath(): string;
 export declare function credentialsPath(): string;
+export declare function codexConfigPath(): string;
+export declare function zedSettingsPath(): string;

package/dist/lib/paths.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.byteDir = byteDir;
 exports.configPath = configPath;
 exports.credentialsPath = credentialsPath;
+exports.codexConfigPath = codexConfigPath;
+exports.zedSettingsPath = zedSettingsPath;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
@@ -17,3 +19,14 @@ function configPath() {
 function credentialsPath() {
     return (0, node_path_1.join)(byteDir(), 'credentials.json');
 }
+function xdgConfigHome() {
+    return process.env.XDG_CONFIG_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), '.config');
+}
+// Canonical config locations for the coding agents Byte auto-wires. Centralised here so
+// detection (detect.ts) and the writers (integrations.ts) never disagree on a path.
+function codexConfigPath() {
+    return (0, node_path_1.join)(process.env.CODEX_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex'), 'config.toml');
+}
+function zedSettingsPath() {
+    return (0, node_path_1.join)(xdgConfigHome(), 'zed', 'settings.json');
+}

package/dist/lib/tui.d.ts

@@ -103,3 +103,45 @@ export declare function useInk(opts?: {
 export declare function computeAscii(): boolean;
 export declare function renderHomeIsland(props: HomeIslandProps): Promise<HomeResult>;
 export declare function renderWizardIsland(props: WizardIslandProps): Promise<WizardResult>;
+export interface DashRequest {
+    model: string;
+    status: string;
+    latencyMs: number;
+    tokens: number;
+    cache?: string;
+}
+export interface DashLayer {
+    label: string;
+    active: boolean;
+}
+export interface DashData {
+    email?: string;
+    org?: string;
+    gateway: 'healthy' | 'down' | 'unknown';
+    mode?: string;
+    requests: number;
+    cacheHitRate: number;
+    savedTotal: number;
+    tokensTotal: number;
+    costTotal: number;
+    savingsSeries: number[];
+    providers: number;
+    models: number;
+    recent: DashRequest[];
+    layers: DashLayer[];
+}
+export interface DashIslandProps {
+    data: DashData;
+    ports: {
+        refresh(): Promise<DashData>;
+    };
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+}
+export type DashResult = {
+    status: 'fallback';
+} | {
+    status: 'exit';
+};
+export declare function renderDashIsland(props: DashIslandProps): Promise<DashResult>;

package/dist/lib/tui.js

@@ -7,6 +7,7 @@ exports.useInk = useInk;
 exports.computeAscii = computeAscii;
 exports.renderHomeIsland = renderHomeIsland;
 exports.renderWizardIsland = renderWizardIsland;
+exports.renderDashIsland = renderDashIsland;
 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
@@ -60,3 +61,12 @@ async function renderWizardIsland(props) {
         return { status: 'fallback' };
     }
 }
+async function renderDashIsland(props) {
+    try {
+        const mod = await importESM(islandUrl());
+        return (await mod.renderDash(props));
+    }
+    catch {
+        return { status: 'fallback' };
+    }
+}

package/dist/lib/wiring.d.ts

@@ -0,0 +1,10 @@
+export interface Wiring {
+    model?: string;
+    preset?: string;
+    tools: string[];
+}
+export declare function getWiring(profile: string): Wiring;
+export declare function setWiring(profile: string, patch: Partial<Wiring>): void;
+export declare function addWiredTool(profile: string, key: string): void;
+export declare function setSelectedModel(profile: string, model: string): void;
+export declare function setSelectedPreset(profile: string, preset: string): void;

package/dist/lib/wiring.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWiring = getWiring;
+exports.setWiring = setWiring;
+exports.addWiredTool = addWiredTool;
+exports.setSelectedModel = setSelectedModel;
+exports.setSelectedPreset = setSelectedPreset;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const paths_1 = require("./paths");
+function wiringPath() {
+    return (0, node_path_1.join)((0, paths_1.byteDir)(), 'wiring.json');
+}
+function load() {
+    try {
+        const data = JSON.parse((0, node_fs_1.readFileSync)(wiringPath(), 'utf8'));
+        return data && typeof data === 'object' ? data : {};
+    }
+    catch {
+        return {};
+    }
+}
+function persist(store) {
+    const path = wiringPath();
+    const tmp = `${path}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    (0, node_fs_1.renameSync)(tmp, path);
+}
+function getWiring(profile) {
+    return load()[profile] || { tools: [] };
+}
+function setWiring(profile, patch) {
+    const store = load();
+    const current = store[profile] || { tools: [] };
+    store[profile] = { ...current, ...patch };
+    persist(store);
+}
+function addWiredTool(profile, key) {
+    const store = load();
+    const current = store[profile] || { tools: [] };
+    if (!current.tools.includes(key))
+        current.tools = [...current.tools, key];
+    store[profile] = current;
+    persist(store);
+}
+function setSelectedModel(profile, model) {
+    if (model)
+        setWiring(profile, { model });
+}
+function setSelectedPreset(profile, preset) {
+    if (preset)
+        setWiring(profile, { preset });
+}

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DashData } from '../contract.js';
+interface DashProps {
+    data: DashData;
+    ports: {
+        refresh(): Promise<DashData>;
+    };
+    ascii: boolean;
+    plainColor: boolean;
+    version: string;
+    onDone: (result: {
+        status: 'fallback' | 'exit';
+    }) => void;
+}
+export declare function Dash({ data: initial, ports, ascii, plainColor, version, onDone }: DashProps): React.ReactElement;
+export {};

package/dist/tui/components/Dash.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput } from 'ink';
+import React from 'react';
+import { glyphs, gradient, tones } from '../theme.js';
+import { Panel } from './Panel.js';
+function Spark({ series, ascii, plainColor }) {
+    const ramp = glyphs(ascii).spark;
+    const values = series.length ? series : [0];
+    const max = Math.max(...values, 1);
+    const cols = gradient(values.length);
+    return (_jsx(Box, { children: values.map((value, i) => {
+            const idx = Math.min(ramp.length - 1, Math.max(0, Math.round((value / max) * (ramp.length - 1))));
+            return (_jsx(Text, { color: plainColor ? undefined : cols[i], children: ramp[idx] }, i));
+        }) }));
+}
+// Dense live monitor: a brand/health header, a one-line metric strip with a savings sparkline,
+// a Recent-requests panel beside an Optimizations panel, and a key-hint footer. Polls the
+// injected refresh port every few seconds; q / Esc / Ctrl-C exits cleanly.
+export function Dash({ data: initial, ports, ascii, plainColor, version, onDone }) {
+    const { exit } = useApp();
+    const [data, setData] = React.useState(initial);
+    const [tick, setTick] = React.useState(0);
+    const t = tones(plainColor);
+    const g = glyphs(ascii);
+    React.useEffect(() => {
+        let alive = true;
+        const timer = setInterval(() => {
+            ports
+                .refresh()
+                .then((next) => {
+                if (alive) {
+                    setData(next);
+                    setTick((n) => n + 1);
+                }
+            })
+                .catch(() => undefined);
+        }, 2500);
+        return () => {
+            alive = false;
+            clearInterval(timer);
+        };
+    }, [ports]);
+    useInput((input, key) => {
+        if (input === 'q' || key.escape || (key.ctrl && input === 'c')) {
+            onDone({ status: 'exit' });
+            exit();
+        }
+    });
+    const dot = data.gateway === 'healthy' ? t.ok : data.gateway === 'down' ? t.bad : t.muted;
+    const recent = data.recent.slice(0, 8);
+    const activeCount = data.layers.filter((l) => l.active).length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: t.brandMid, bold: true, children: [g.brand.join(''), " byte dash "] }), _jsxs(Text, { color: t.muted, children: ["v", version, "  "] }), _jsxs(Text, { color: dot, children: [g.filled, " ", data.gateway] }), _jsxs(Text, { color: t.muted, children: ["   ", data.email ?? '', data.org ? ` (${data.org})` : ''] })] }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: t.muted, children: "mode " }), _jsx(Text, { color: t.accent, children: data.mode ?? 'maximum' }), _jsx(Text, { color: t.muted, children: "   saved " }), _jsxs(Text, { color: t.ok, children: ["$", data.savedTotal.toFixed(4)] }), _jsx(Text, { color: t.muted, children: "   req " }), _jsx(Text, { children: data.requests }), _jsx(Text, { color: t.muted, children: "   cache " }), _jsxs(Text, { color: t.accent, children: [Math.round(data.cacheHitRate * 100), "%"] }), _jsx(Text, { color: t.muted, children: "   tok " }), _jsx(Text, { children: data.tokensTotal }), _jsx(Text, { color: t.muted, children: "   " }), _jsx(Spark, { series: data.savingsSeries, ascii: ascii, plainColor: plainColor })] }), _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: "56%", marginRight: 1, children: _jsx(Panel, { title: "Recent requests", ascii: ascii, plainColor: plainColor, children: recent.length === 0 ? (_jsx(Text, { color: t.muted, children: "no requests yet" })) : (recent.map((r, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: r.status === 'ok' ? t.ok : t.bad, children: [g.bullet, " "] }), _jsx(Text, { children: r.model.padEnd(22).slice(0, 22) }), _jsxs(Text, { color: t.muted, children: [" ", String(r.latencyMs).padStart(5), "ms "] }), _jsxs(Text, { color: t.muted, children: [String(r.tokens).padStart(6), "tok "] }), _jsx(Text, { color: t.accent, children: r.cache ?? '' })] }, i)))) }) }), _jsx(Box, { width: "42%", children: _jsx(Panel, { title: `Optimizations ${activeCount}/${data.layers.length}`, tone: "ok", ascii: ascii, plainColor: plainColor, children: data.layers.slice(0, 12).map((l, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: l.active ? t.ok : t.muted, children: [l.active ? g.filled : g.empty, " "] }), _jsx(Text, { color: l.active ? undefined : t.muted, children: l.label })] }, i))) }) })] }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: t.muted, children: ["providers ", data.providers, " \u00B7 models ", data.models, " \u00B7 refresh #", tick, "    "] }), _jsx(Text, { color: t.accent, children: "q" }), _jsx(Text, { color: t.muted, children: " quit" })] })] }));
+}

package/dist/tui/contract.d.ts

@@ -97,3 +97,45 @@ export type WizardResult = {
     status: 'done';
     summary: WizardSummary;
 };
+export interface DashRequest {
+    model: string;
+    status: string;
+    latencyMs: number;
+    tokens: number;
+    cache?: string;
+}
+export interface DashLayer {
+    label: string;
+    active: boolean;
+}
+export interface DashData {
+    email?: string;
+    org?: string;
+    gateway: 'healthy' | 'down' | 'unknown';
+    mode?: string;
+    requests: number;
+    cacheHitRate: number;
+    savedTotal: number;
+    tokensTotal: number;
+    costTotal: number;
+    savingsSeries: number[];
+    providers: number;
+    models: number;
+    recent: DashRequest[];
+    layers: DashLayer[];
+}
+export interface DashPorts {
+    refresh(): Promise<DashData>;
+}
+export interface DashIslandProps {
+    data: DashData;
+    ports: DashPorts;
+    plainColor: boolean;
+    ascii: boolean;
+    version: string;
+}
+export type DashResult = {
+    status: 'fallback';
+} | {
+    status: 'exit';
+};

package/dist/tui/index.d.ts

@@ -1,3 +1,4 @@
-import type { HomeIslandProps, HomeResult, WizardIslandProps, WizardResult } from './contract.js';
+import type { DashIslandProps, DashResult, HomeIslandProps, HomeResult, WizardIslandProps, WizardResult } from './contract.js';
 export declare function renderHome(props: HomeIslandProps): Promise<HomeResult>;
 export declare function renderWizard(props: WizardIslandProps): Promise<WizardResult>;
+export declare function renderDash(props: DashIslandProps): Promise<DashResult>;