@bytevion/cli 0.1.0 → 0.3.0

package/dist/hooks/init/home.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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
+// terminal opens the live home dashboard + an interactive menu; anything else (a command,
+// a pipe, CI, --help) returns and lets oclif behave normally.
+const hook = async function (opts) {
+    if (opts.id !== undefined)
+        return;
+    const argv = opts.argv ?? [];
+    if (argv.length > 0)
+        return;
+    if (!(0, tty_1.interactive)())
+        return;
+    const profile = (0, config_1.profileName)();
+    const prof = (0, config_1.getProfile)(profile);
+    const token = (0, credentials_1.getToken)(profile);
+    const signedIn = Boolean(token);
+    const byteKey = (0, credentials_1.getByteKey)(profile);
+    // Live, branded home dashboard. Every cell is best-effort: an unreachable service or a
+    // signed-out profile degrades to a dim placeholder rather than blocking the screen.
+    let data = { savingsSeries: [], savedTotal: 0, tokensTotal: 0, byteKey, gateway: 'unknown' };
+    if (signedIn) {
+        const api = new api_1.ByteApi(prof.base_url || config_1.DEFAULT_BASE_URL, token);
+        const loaded = await (0, home_1.loadHomeData)(api, byteKey, profile).catch(() => undefined);
+        if (loaded)
+            data = { ...data, ...loaded };
+    }
+    this.log(`\n${(0, home_1.renderHome)(data, signedIn)}\n`);
+    const choice = await ui.select({
+        message: 'What would you like to do?',
+        initialValue: signedIn ? 'setup' : 'login',
+        options: [
+            { value: 'setup', label: 'Set up Byte', hint: 'guided' },
+            { value: 'providers:add', label: 'Connect a provider' },
+            { value: 'keys:create', label: 'Create a Byte key' },
+            { value: 'integrate', label: 'Connect a tool' },
+            { value: 'run', label: 'Run a test prompt' },
+            { value: 'compare', label: 'Compare direct vs Byte', hint: 'prove the win' },
+            { value: 'usage', label: 'View usage' },
+            { value: signedIn ? 'logout' : 'login', label: signedIn ? 'Sign out' : 'Sign in' },
+            { value: 'exit', label: 'Exit' },
+        ],
+    });
+    if (choice === 'exit') {
+        await ui.outro('Bye.');
+        await this.exit(0);
+        return;
+    }
+    let cmdId = choice;
+    let cmdArgv = [];
+    if (choice === 'run') {
+        const prompt = await ui.text({ message: 'Prompt', placeholder: 'hello from byte', defaultValue: 'hello from byte' });
+        cmdId = 'run';
+        cmdArgv = [prompt || 'hello from byte'];
+    }
+    else if (choice === 'compare') {
+        const prompt = await ui.text({ message: 'Prompt to compare', placeholder: 'Summarize the latest changes', defaultValue: 'Summarize the latest changes' });
+        cmdId = 'compare';
+        cmdArgv = [prompt || 'Summarize the latest changes'];
+    }
+    else if (choice === 'keys:create') {
+        const name = await ui.text({ message: 'Key name', defaultValue: 'cli' });
+        cmdArgv = [name || 'cli'];
+    }
+    await this.config.runCommand(cmdId, cmdArgv);
+    await this.exit(0);
+};
+exports.default = hook;

package/dist/lib/api.d.ts

@@ -36,5 +36,6 @@ export declare class ByteApi {
     chat(byteKey: string, body: Record<string, unknown>): Promise<any>;
     models(byteKey: string): Promise<any>;
     probeMessages(byteKey: string): Promise<any>;
+    compareStream(body: Record<string, unknown>): AsyncGenerator<any>;
 }
 export {};

package/dist/lib/api.js

@@ -143,5 +143,65 @@ class ByteApi {
             body: { model: 'byte-default', max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] },
         });
     }
+    // --- compare (direct vs Byte) — Server-Sent Events ---
+    async *compareStream(body) {
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}/api/v1/compare/chat`, {
+                method: 'POST',
+                headers: {
+                    ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'network error';
+            throw new errors_1.ByteError(`Cannot reach ${this.baseUrl} (${message})`, 'BYTE_API_OFFLINE', 5, 0);
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            let detail = res.statusText;
+            try {
+                detail = JSON.parse(text).detail ?? detail;
+            }
+            catch {
+                /* keep statusText */
+            }
+            const code = typeof detail === 'string' ? detail : 'BYTE_HTTP_ERROR';
+            throw new errors_1.ByteError(typeof detail === 'string' ? detail : JSON.stringify(detail), code, (0, errors_1.exitForStatus)(res.status), res.status);
+        }
+        const reader = res.body?.getReader();
+        if (!reader)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const parts = buffer.split('\n\n');
+            buffer = parts.pop() ?? '';
+            for (const part of parts) {
+                for (const line of part.split('\n')) {
+                    const trimmed = line.trim();
+                    if (!trimmed.startsWith('data:'))
+                        continue;
+                    const raw = trimmed.slice(5).trim();
+                    if (!raw || raw === '[DONE]')
+                        continue;
+                    try {
+                        yield JSON.parse(raw);
+                    }
+                    catch {
+                        /* ignore non-JSON keepalives */
+                    }
+                }
+            }
+        }
+    }
 }
 exports.ByteApi = ByteApi;

package/dist/lib/auth.d.ts

@@ -0,0 +1,9 @@
+export interface LoginResult {
+    email?: string;
+    org?: string;
+}
+export declare function deviceLogin(opts: {
+    baseUrl: string;
+    profile: string;
+    noBrowser?: boolean;
+}): Promise<LoginResult>;

package/dist/lib/auth.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceLogin = deviceLogin;
+const node_os_1 = require("node:os");
+const api_1 = require("./api");
+const config_1 = require("./config");
+const credentials_1 = require("./credentials");
+const errors_1 = require("./errors");
+const ui = __importStar(require("./ui"));
+const util_1 = require("./util");
+// Device-code login loop shared by `byte login` and the setup wizard. Prints the
+// user code, opens the browser, and polls with backoff until approved/denied/expired.
+async function deviceLogin(opts) {
+    const api = new api_1.ByteApi(opts.baseUrl);
+    const start = await api.deviceStart(`byte-cli@${(0, node_os_1.hostname)()}`);
+    const verifyUrl = start.verification_uri_complete || start.verification_uri;
+    await ui.note(`${ui.theme.bold(start.user_code)}\n\n${verifyUrl}`, 'Approve this device in your browser');
+    if (!opts.noBrowser) {
+        try {
+            await (0, util_1.openBrowser)(verifyUrl);
+        }
+        catch {
+            // user can open the URL manually
+        }
+    }
+    const spin = await ui.spinner();
+    spin.start('Waiting for approval…');
+    let interval = (Number(start.interval) || 5) * 1000;
+    const deadline = Date.now() + (Number(start.expires_in) || 600) * 1000;
+    while (Date.now() < deadline) {
+        await (0, util_1.sleep)(interval);
+        try {
+            const tok = await api.deviceToken(start.device_code);
+            (0, credentials_1.setToken)(opts.profile, tok.access_token);
+            (0, config_1.setProfile)(opts.profile, {
+                base_url: opts.baseUrl,
+                dashboard_url: (0, config_1.getProfile)(opts.profile).dashboard_url || config_1.DEFAULT_DASHBOARD_URL,
+                org_id: tok.org?.id,
+                org_name: tok.org?.name,
+                email: tok.user?.email,
+            });
+            spin.stop('Signed in.');
+            return { email: tok.user?.email, org: tok.org?.name };
+        }
+        catch (err) {
+            const code = err instanceof errors_1.ByteError ? err.code : '';
+            if (code === 'authorization_pending')
+                continue;
+            if (code === 'slow_down') {
+                interval += 5000;
+                continue;
+            }
+            if (code === 'access_denied') {
+                spin.stop('Authorization denied.');
+                throw new errors_1.ByteError('Authorization was denied in the dashboard.', 'BYTE_AUTH_DENIED', 3);
+            }
+            if (code === 'expired_token') {
+                spin.stop('Code expired.');
+                throw new errors_1.ByteError('The verification code expired. Run `byte login` again.', 'BYTE_AUTH_EXPIRED', 3);
+            }
+            spin.stop('Login failed.');
+            throw err;
+        }
+    }
+    spin.stop('Timed out.');
+    throw new errors_1.ByteError('Login timed out. Run `byte login` again.', 'BYTE_AUTH_TIMEOUT', 3);
+}

package/dist/lib/friendly.d.ts

@@ -0,0 +1,8 @@
+import { ByteError } from './errors';
+export interface Friendly {
+    issue: string;
+    why: string;
+    next: string;
+}
+export declare function friendlyError(err: ByteError): Friendly;
+export declare function renderErrorPanel(f: Friendly): string;

package/dist/lib/friendly.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.friendlyError = friendlyError;
+exports.renderErrorPanel = renderErrorPanel;
+const picocolors_1 = __importDefault(require("picocolors"));
+// Translates a ByteError (HTTP status + BYTE_* / provider detail code) into plain
+// language a first-time user can act on: what happened, why, and the exact next
+// command. The goal is that no error ever leaves someone stuck.
+function friendlyError(err) {
+    const code = (err.code || '').toUpperCase();
+    const status = err.status;
+    const byCode = {
+        BYTE_AUTH_REQUIRED: {
+            issue: 'You are not signed in yet.',
+            why: 'This command needs your Byte account.',
+            next: 'byte login',
+        },
+        BYTE_KEY_REQUIRED: {
+            issue: 'This profile has no Byte API key.',
+            why: 'Requests run through a Byte key so every optimization applies automatically.',
+            next: 'byte keys create',
+        },
+        BYTE_API_OFFLINE: {
+            issue: 'Could not reach the Byte service.',
+            why: 'You may be offline, or the base URL is pointed somewhere unexpected.',
+            next: 'byte doctor',
+        },
+        BYTE_MODEL_FETCH_FAILED: {
+            issue: 'Your provider was saved, but its model list could not be loaded.',
+            why: 'The provider URL or key looks unreachable right now — your connection is still saved.',
+            next: 'byte providers test',
+        },
+        BYTE_DEVICE_DENIED: {
+            issue: 'Sign-in was declined in the browser.',
+            why: 'The device approval was rejected or closed.',
+            next: 'byte login',
+        },
+        BYTE_DEVICE_EXPIRED: {
+            issue: 'The sign-in code expired.',
+            why: 'It was not approved in time.',
+            next: 'byte login',
+        },
+    };
+    if (byCode[code])
+        return byCode[code];
+    if (status === 0) {
+        return { issue: 'Could not reach the Byte service.', why: 'You may be offline.', next: 'byte doctor' };
+    }
+    if (status === 401 || status === 403) {
+        return { issue: 'Your session or key was rejected.', why: 'It may have expired, been revoked, or be missing a scope.', next: 'byte login' };
+    }
+    if (status === 404) {
+        return {
+            issue: 'That route or model was not found.',
+            why: 'The model may not be wired to your key, or the surface (e.g. /v1/messages) is not enabled for it.',
+            next: 'byte doctor',
+        };
+    }
+    if (status === 429) {
+        return { issue: 'Rate limit reached.', why: 'Too many requests landed in a short window.', next: 'wait a few seconds, then retry' };
+    }
+    if (status && status >= 500) {
+        return {
+            issue: 'The service hit an error finishing your request.',
+            why: 'This is on the Byte side, not your input — your key and provider are fine.',
+            next: 'byte doctor   (then retry shortly)',
+        };
+    }
+    return { issue: err.message || 'Something went wrong.', why: `Error code: ${err.code}`, next: 'byte doctor' };
+}
+// A compact, left-accent error panel. picocolors auto-disables under NO_COLOR, so this
+// degrades to clean monochrome text in plain terminals.
+function renderErrorPanel(f) {
+    const bar = picocolors_1.default.red('▌');
+    const lines = [
+        `${bar} ${picocolors_1.default.bold(picocolors_1.default.red('Byte hit a problem'))}`,
+        `${bar} ${f.issue}`,
+        `${bar}`,
+        `${bar} ${picocolors_1.default.dim('Why ')}  ${f.why}`,
+        `${bar} ${picocolors_1.default.dim('Next')}  ${picocolors_1.default.cyan(f.next)}`,
+    ];
+    return `\n${lines.join('\n')}\n`;
+}

package/dist/lib/home.d.ts

@@ -0,0 +1,16 @@
+import { ByteApi } from './api';
+export declare function wordmark(): string;
+export interface HomeData {
+    email?: string;
+    org?: string;
+    providers?: number;
+    models?: number;
+    byteKey?: string;
+    gateway?: 'healthy' | 'down' | 'unknown';
+    savingsSeries: number[];
+    savedTotal: number;
+    tokensTotal: number;
+    hitRate?: number;
+}
+export declare function loadHomeData(api: ByteApi, byteKey: string | undefined, fallbackId: string): Promise<HomeData>;
+export declare function renderHome(data: HomeData, signedIn: boolean): string;

package/dist/lib/home.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordmark = wordmark;
+exports.loadHomeData = loadHomeData;
+exports.renderHome = renderHome;
+const picocolors_1 = __importDefault(require("picocolors"));
+const output_1 = require("./output");
+const ANSI = /\x1b\[[0-9;]*m/g;
+const visLen = (s) => s.replace(ANSI, '').length;
+const plainMode = () => Boolean(process.env.NO_COLOR) || process.env.BYTE_PLAIN === '1';
+// Cyan→blue gradient wordmark. picocolors has no true gradient, so we step the letters
+// across a cyan→blue ramp — a recognizable Byte signature that degrades to plain text.
+function wordmark() {
+    const mark = `${picocolors_1.default.dim('›')}${picocolors_1.default.bold(picocolors_1.default.cyanBright('b'))}${picocolors_1.default.dim('_')}`;
+    if (plainMode())
+        return `${mark} BYTE`;
+    const ramp = [picocolors_1.default.cyanBright, picocolors_1.default.cyan, picocolors_1.default.blue, picocolors_1.default.blueBright];
+    const name = 'BYTE'
+        .split('')
+        .map((ch, i) => picocolors_1.default.bold(ramp[i % ramp.length](ch)))
+        .join('');
+    return `${mark}  ${name}`;
+}
+function box(lines, pad = 2) {
+    const inner = Math.max(...lines.map(visLen));
+    const horiz = '─'.repeat(inner + pad * 2);
+    const body = lines.map((l) => `${picocolors_1.default.dim('│')}${' '.repeat(pad)}${l}${' '.repeat(inner - visLen(l) + pad)}${picocolors_1.default.dim('│')}`);
+    return [picocolors_1.default.dim(`╭${horiz}╮`), ...body, picocolors_1.default.dim(`╰${horiz}╯`)].join('\n');
+}
+function withTimeout(p, ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(undefined), ms);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        p.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, () => {
+            clearTimeout(timer);
+            resolve(undefined);
+        });
+    });
+}
+// Fetches everything bare `byte` shows, in parallel, each guarded by a short timeout so a
+// slow or unreachable service never blocks the home screen — missing cells just render dim.
+async function loadHomeData(api, byteKey, fallbackId) {
+    const [me, provs, usage, health] = await Promise.all([
+        withTimeout(api.me(), 4000),
+        withTimeout(api.providersList(), 4000),
+        withTimeout(api.usage('day'), 4000),
+        withTimeout(api.health(), 3000),
+    ]);
+    const conns = provs?.connections ?? (Array.isArray(provs) ? provs : []);
+    const models = conns.reduce((a, c) => a + (Number(c.models ?? c.model_count ?? 0) || 0), 0);
+    const series = usage?.series ?? [];
+    const num = (v) => {
+        const n = typeof v === 'number' ? v : Number(v);
+        return Number.isFinite(n) ? n : 0;
+    };
+    const requests = series.reduce((a, p) => a + num(p.requests), 0);
+    const cached = series.reduce((a, p) => a + num(p.cached), 0);
+    return {
+        email: me?.user?.email,
+        org: me?.org?.name ?? me?.user?.org_name,
+        providers: conns.length || undefined,
+        models: models || undefined,
+        byteKey,
+        gateway: health ? (health.status === 'ok' || health.ok ? 'healthy' : 'down') : 'unknown',
+        savingsSeries: series.map((p) => num(p.savings_usd)),
+        savedTotal: series.reduce((a, p) => a + num(p.savings_usd), 0),
+        tokensTotal: series.reduce((a, p) => a + num(p.tokens_in) + num(p.tokens_out), 0),
+        hitRate: requests > 0 ? cached / requests : undefined,
+    };
+}
+function renderHome(data, signedIn) {
+    const dim = picocolors_1.default.dim;
+    const label = (s) => dim(s.padEnd(10));
+    const dash = dim('—');
+    const gatewayDot = data.gateway === 'healthy' ? `${picocolors_1.default.green('●')} healthy` : data.gateway === 'down' ? `${picocolors_1.default.red('●')} unreachable` : dim('● unknown');
+    const lines = [
+        `${wordmark()}${' '.repeat(6)}${dim('optimization gateway')}`,
+        '',
+        `${label('Account')}${signedIn ? `${data.email ?? 'you'}${data.org ? `  ${dim('·')}  ${data.org}` : ''}` : picocolors_1.default.yellow('not signed in')}`,
+        `${label('Providers')}${data.providers ? `${data.providers} connected${data.models ? `  ${dim('·')}  ${data.models} models` : ''}` : dash}`,
+        `${label('Byte key')}${data.byteKey ? picocolors_1.default.cyan((0, output_1.maskKey)(data.byteKey)) : dash}`,
+        `${label('Gateway')}${gatewayDot}`,
+    ];
+    if (data.savingsSeries.some((v) => v > 0) || data.savedTotal > 0) {
+        const spark = (0, output_1.sparkline)(data.savingsSeries, plainMode());
+        const summary = `${picocolors_1.default.green((0, output_1.fmtUsd)(data.savedTotal))} saved  ${dim('·')}  ${(0, output_1.fmtNum)(data.tokensTotal)} tokens${data.hitRate !== undefined ? `  ${dim('·')}  ${(0, output_1.pct)(data.hitRate)} cache hits` : ''}`;
+        lines.push('', `${label('7-day')}${picocolors_1.default.cyan(spark)}  ${summary}`);
+    }
+    return box(lines);
+}

package/dist/lib/integrations.d.ts

@@ -2,6 +2,7 @@ export type Compat = 'openai' | 'anthropic';
 export interface IntegrationContext {
     baseUrl: string;
     byteKey: string;
+    modelAlias: string;
 }
 export interface SettingsFile {
     path: string;