@bytevion/cli 0.1.0 → 0.2.0

package/dist/commands/providers/rotate.js

@@ -1,8 +1,42 @@
 "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 core_1 = require("@oclif/core");
 const base_1 = require("../../base");
-const util_1 = require("../../lib/util");
+const tty_1 = require("../../lib/tty");
+const ui = __importStar(require("../../lib/ui"));
 class ProvidersRotate extends base_1.BaseCommand {
     static description = 'Replace the upstream API key on a provider connection (keeps imported models).';
     static args = {
@@ -15,10 +49,11 @@ class ProvidersRotate extends base_1.BaseCommand {
         const { args, flags } = await this.parse(ProvidersRotate);
         this.requireToken(flags);
         let apiKey = flags['api-key'];
+        if (!apiKey && (0, tty_1.interactive)() && !this.jsonEnabled()) {
+            apiKey = await ui.password({ message: 'New upstream provider API key', validate: (v) => (v.trim() ? undefined : 'Required') });
+        }
         if (!apiKey)
-            apiKey = await (0, util_1.promptHidden)('New upstream provider API key: ');
-        if (!apiKey)
-            return this.error('A provider API key is required.', { exit: 2 });
+            return this.error('Missing --api-key.', { exit: 2 });
         const res = await this.api(flags).providersRotate(args.id, apiKey);
         if (!this.jsonEnabled())
             this.log(`Rotated provider key on connection ${args.id} (now ****${res.secret_last4 ?? '????'}).`);

package/dist/commands/setup.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../base';
+export default class Setup extends BaseCommand {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        provider: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'provider-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'provider-base-url': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        preset: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'key-name': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'skip-provider': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        connect: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+    private connectProvider;
+    private runNonInteractive;
+}

package/dist/commands/setup.js

@@ -0,0 +1,201 @@
+"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 core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const auth_1 = require("../lib/auth");
+const credentials_1 = require("../lib/credentials");
+const providers_1 = require("../lib/providers");
+const tty_1 = require("../lib/tty");
+const ui = __importStar(require("../lib/ui"));
+class Setup extends base_1.BaseCommand {
+    static description = 'Guided setup: sign in, connect a provider, create a Byte key, and wire a tool.';
+    static aliases = ['init', 'onboard'];
+    static examples = ['<%= config.bin %> setup', '<%= config.bin %> setup --provider deepseek --provider-key sk-... --connect opencode --json'];
+    static flags = {
+        provider: core_1.Flags.string({ description: 'Provider preset id (openai, deepseek, anthropic, …)' }),
+        'provider-key': core_1.Flags.string({ description: 'Upstream provider API key', env: 'BYTE_PROVIDER_KEY' }),
+        'provider-base-url': core_1.Flags.string({ description: 'Custom provider base URL (for --provider custom)' }),
+        mode: core_1.Flags.string({ description: 'Gateway mode override (byte_compatible/byte_messages/byte_generative)' }),
+        preset: core_1.Flags.string({
+            description: 'Optimization preset',
+            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+            default: 'balanced',
+        }),
+        'key-name': core_1.Flags.string({ description: 'Name for the Byte key', default: 'cli' }),
+        'skip-provider': core_1.Flags.boolean({ description: 'Skip connecting a provider' }),
+        connect: core_1.Flags.string({ description: 'Tool to wire after setup (e.g. opencode, codex)' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Setup);
+        const profile = this.profileFrom(flags);
+        const base = this.baseUrlFrom(flags);
+        if (this.jsonEnabled() || !(0, tty_1.interactive)()) {
+            return this.runNonInteractive(flags, profile, base);
+        }
+        await ui.intro(ui.banner());
+        // 1) Sign in
+        let token = (0, credentials_1.getToken)(profile);
+        const api = this.api(flags);
+        if (token) {
+            try {
+                const me = await api.me();
+                await ui.log.info(`Signed in as ${me.user?.email ?? 'you'}`);
+            }
+            catch {
+                token = undefined;
+            }
+        }
+        if (!token) {
+            await (0, auth_1.deviceLogin)({ baseUrl: base, profile });
+        }
+        // 2) Connect a provider
+        let chosenAlias;
+        if (!flags['skip-provider']) {
+            const existing = await api.providersList().catch(() => ({ connections: [] }));
+            const conns = existing.connections ?? (Array.isArray(existing) ? existing : []);
+            let addNew = true;
+            if (conns.length) {
+                addNew = (await ui.select({
+                    message: 'Provider',
+                    options: [
+                        { value: 'existing', label: `Use existing connection (${conns.length})` },
+                        { value: 'new', label: 'Connect a new provider' },
+                    ],
+                })) === 'new';
+            }
+            if (addNew) {
+                chosenAlias = await this.connectProvider(api, flags);
+            }
+        }
+        // 3) Create a Byte key
+        let byteKey = (0, credentials_1.getByteKey)(profile);
+        if (!byteKey) {
+            const name = await ui.text({ message: 'Name this Byte key', defaultValue: flags['key-name'] || 'cli' });
+            const res = await api.keysCreate({ name: name || 'cli', preset: flags.preset });
+            const created = String(res.key);
+            (0, credentials_1.setByteKey)(profile, created);
+            await ui.revealSecret('Your Byte API key', created);
+        }
+        // 4) Optimization preset
+        await api.optPatch({ default_mode: flags.preset }).catch(() => undefined);
+        await ui.log.success(`Optimizations: ${flags.preset} preset applied`);
+        // 5) Connect a tool
+        const connect = await ui.select({
+            message: 'Connect a coding tool now?',
+            options: [
+                { value: 'skip', label: 'Skip for now' },
+                { value: 'opencode', label: 'opencode' },
+                { value: 'claude-code', label: 'Claude Code' },
+                { value: 'codex', label: 'Codex CLI' },
+                { value: 'cursor', label: 'Cursor' },
+                { value: 'cline', label: 'Cline' },
+                { value: 'aider', label: 'Aider' },
+            ],
+        });
+        if (connect !== 'skip') {
+            const argv = [connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])];
+            await this.config.runCommand('integrate', argv);
+        }
+        await ui.outro(`${ui.theme.ok('Setup complete.')}  Next: ${ui.theme.accent('byte run "hello from byte"')} · ${ui.theme.accent('byte usage')}`);
+        return { status: 'setup_complete', profile, model: chosenAlias };
+    }
+    async connectProvider(api, flags) {
+        const providerId = await ui.select({
+            message: 'Which provider?',
+            options: providers_1.PROVIDER_PRESETS.map((p) => ({ value: p.id, label: p.label, hint: p.advanced ? 'advanced' : undefined })),
+        });
+        const preset = (0, providers_1.findPreset)(providerId);
+        let baseUrl = preset.base_url;
+        if (preset.custom || !baseUrl) {
+            baseUrl = await ui.text({
+                message: 'Provider base URL',
+                placeholder: 'https://api.example.com/v1',
+                validate: (v) => (v.startsWith('http') ? undefined : 'Must be a URL'),
+            });
+        }
+        if (preset.advanced && preset.note)
+            await ui.log.warn(preset.note);
+        const key = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
+        const spin = await ui.spinner();
+        spin.start(`Connecting ${preset.label}…`);
+        try {
+            const res = await api.providersAdd({ api_key: key, gateway_mode: flags.mode || preset.gateway_mode, base_url: baseUrl, auto_fetch: true });
+            const models = res.fetch_result?.models ?? res.models ?? [];
+            spin.stop(`Connected ${preset.label} — ${models.length} model(s) imported.`);
+            if (models.length) {
+                return ui.select({
+                    message: 'Default model',
+                    options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
+                });
+            }
+        }
+        catch (err) {
+            spin.stop('Provider connection failed.');
+            await ui.log.error(err?.message ?? String(err));
+        }
+        return undefined;
+    }
+    async runNonInteractive(flags, profile, base) {
+        this.requireToken(flags);
+        const api = this.api(flags);
+        let imported = 0;
+        let chosenAlias;
+        const key = flags['provider-key'];
+        if (key && !flags['skip-provider']) {
+            const preset = flags.provider ? (0, providers_1.findPreset)(flags.provider) : undefined;
+            const baseUrl = flags['provider-base-url'] || preset?.base_url;
+            const mode = flags.mode || preset?.gateway_mode || 'byte_compatible';
+            if (!baseUrl) {
+                return this.error('Provide --provider <preset> or --provider-base-url for the upstream provider.', { exit: 2 });
+            }
+            const res = await api.providersAdd({ api_key: key, gateway_mode: mode, base_url: baseUrl, auto_fetch: true });
+            imported = res.fetch_result?.imported ?? res.imported ?? 0;
+            chosenAlias = res.fetch_result?.models?.[0]?.byte_alias;
+        }
+        await api.optPatch({ default_mode: flags.preset }).catch(() => undefined);
+        const keyRes = await api.keysCreate({ name: flags['key-name'] || 'cli', preset: flags.preset });
+        (0, credentials_1.setByteKey)(profile, keyRes.key);
+        if (flags.connect) {
+            await this.config.runCommand('integrate', [flags.connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])]);
+        }
+        if (!this.jsonEnabled()) {
+            this.log(`Byte key: ${keyRes.key}`);
+            this.log(`Provider models imported: ${imported}`);
+        }
+        return { byte_key: keyRes.key, provider_models_imported: imported, preset: flags.preset, model: chosenAlias };
+    }
+}
+exports.default = Setup;

package/dist/hooks/init/home.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'init'>;
+export default hook;

package/dist/hooks/init/home.js

@@ -0,0 +1,95 @@
+"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 config_1 = require("../../lib/config");
+const credentials_1 = require("../../lib/credentials");
+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 an interactive home 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 signedIn = Boolean((0, credentials_1.getToken)(profile));
+    const status = signedIn ? ui.theme.muted(`signed in · ${prof.email ?? prof.org_name ?? profile}`) : ui.theme.muted('not signed in');
+    await ui.intro(`${ui.banner()}   ${status}`);
+    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/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;