@bytevion/cli 0.1.0

package/bin/run.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// CommonJS entry. @oclif/core ships as ESM, so load it via dynamic import.
+;(async () => {
+  const { execute } = await import('@oclif/core')
+  await execute({ dir: __dirname })
+})()

package/dist/base.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+import { ByteApi } from './lib/api';
+export declare abstract class BaseCommand extends Command {
+    static enableJsonFlag: boolean;
+    static baseFlags: {
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    protected profileFrom(flags: Record<string, any>): string;
+    protected baseUrlFrom(flags: Record<string, any>): string;
+    protected api(flags: Record<string, any>, opts?: {
+        auth?: boolean;
+    }): ByteApi;
+    protected requireToken(flags: Record<string, any>): string;
+    protected requireByteKey(flags: Record<string, any>): string;
+    protected optionalByteKey(flags: Record<string, any>): string | undefined;
+    protected catch(err: Error & {
+        exitCode?: number;
+    }): Promise<unknown>;
+}

package/dist/base.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const core_1 = require("@oclif/core");
+const api_1 = require("./lib/api");
+const config_1 = require("./lib/config");
+const credentials_1 = require("./lib/credentials");
+const errors_1 = require("./lib/errors");
+class BaseCommand extends core_1.Command {
+    static enableJsonFlag = true;
+    static baseFlags = {
+        profile: core_1.Flags.string({ description: 'Configuration profile to use', env: 'BYTE_PROFILE' }),
+        'base-url': core_1.Flags.string({ description: 'Override the API base URL', env: 'BYTE_BASE_URL' }),
+    };
+    profileFrom(flags) {
+        return (0, config_1.profileName)(flags.profile);
+    }
+    baseUrlFrom(flags) {
+        return flags['base-url'] || (0, config_1.getProfile)(this.profileFrom(flags)).base_url || config_1.DEFAULT_BASE_URL;
+    }
+    api(flags, opts = {}) {
+        const token = opts.auth === false ? undefined : (0, credentials_1.getToken)(this.profileFrom(flags));
+        return new api_1.ByteApi(this.baseUrlFrom(flags), token);
+    }
+    requireToken(flags) {
+        const stored = (0, credentials_1.getToken)(this.profileFrom(flags));
+        if (!stored) {
+            throw new errors_1.ByteError('Not signed in. Run `byte login` first.', 'BYTE_AUTH_REQUIRED', 3);
+        }
+        return stored;
+    }
+    requireByteKey(flags) {
+        const key = (0, credentials_1.getByteKey)(this.profileFrom(flags));
+        if (!key) {
+            throw new errors_1.ByteError('No Byte API key for this profile. Run `byte init` or `byte keys create`.', 'BYTE_KEY_REQUIRED', 4);
+        }
+        return key;
+    }
+    optionalByteKey(flags) {
+        return (0, credentials_1.getByteKey)(this.profileFrom(flags));
+    }
+    async catch(err) {
+        if (err instanceof errors_1.ByteError) {
+            return this.error(err.message, { code: err.code, exit: err.exit });
+        }
+        return super.catch(err);
+    }
+}
+exports.BaseCommand = BaseCommand;

package/dist/commands/batch/list.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from '../../base';
+export default class BatchList extends BaseCommand {
+    static description: string;
+    run(): Promise<unknown>;
+}

package/dist/commands/batch/list.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class BatchList extends base_1.BaseCommand {
+    static description = 'List recent batch jobs for the current org.';
+    async run() {
+        const { flags } = await this.parse(BatchList);
+        this.requireToken(flags);
+        const res = await this.api(flags).batchList();
+        const jobs = res.jobs ?? res ?? [];
+        if (this.jsonEnabled())
+            return jobs;
+        if (!jobs.length) {
+            this.log('No batch jobs yet. Submit one with `byte batch submit <file>`.');
+            return jobs;
+        }
+        this.log((0, output_1.renderTable)(['Job ID', 'Status', 'Model', 'Created'], jobs.map((j) => [j.id, j.status, j.model, j.created_at ?? '-'])));
+        return jobs;
+    }
+}
+exports.default = BatchList;

package/dist/commands/batch/poll.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base';
+export default class BatchPoll extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        run: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        watch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/batch/poll.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const util_1 = require("../../lib/util");
+const PENDING = new Set(['queued', 'running', 'processing', 'pending']);
+class BatchPoll extends base_1.BaseCommand {
+    static description = 'Show a batch job, optionally starting it and/or watching until it finishes.';
+    static args = {
+        id: core_1.Args.string({ description: 'Job id (see `byte batch list`)', required: true }),
+    };
+    static flags = {
+        run: core_1.Flags.boolean({ description: 'Start the job before polling' }),
+        watch: core_1.Flags.boolean({ description: 'Poll until the job leaves a pending state' }),
+        interval: core_1.Flags.integer({ description: 'Seconds between polls when watching', default: 3 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(BatchPoll);
+        this.requireToken(flags);
+        const api = this.api(flags);
+        let job = flags.run ? (await api.batchRun(args.id)).job : (await api.batchGet(args.id)).job;
+        while (flags.watch && job && PENDING.has(String(job.status))) {
+            // eslint-disable-next-line no-await-in-loop
+            await (0, util_1.sleep)(Math.max(1, flags.interval) * 1000);
+            // eslint-disable-next-line no-await-in-loop
+            job = (await api.batchGet(args.id)).job;
+            if (!this.jsonEnabled())
+                this.log(`  status: ${job?.status}`);
+        }
+        if (this.jsonEnabled())
+            return job;
+        this.log(`Job ${args.id}: ${job?.status}`);
+        if (job?.error_code)
+            this.log(`Error: ${job.error_code}`);
+        if (job?.result_content) {
+            this.log('');
+            this.log(job.result_content);
+        }
+        return job;
+    }
+}
+exports.default = BatchPoll;

package/dist/commands/batch/submit.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base';
+export default class BatchSubmit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        model: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'auto-start': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/batch/submit.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_fs_1 = require("node:fs");
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+function normalizeSpec(item) {
+    if (Array.isArray(item))
+        return { messages: item };
+    if (item && Array.isArray(item.messages))
+        return { model: item.model, messages: item.messages };
+    throw new Error('Each job must be a messages array or an object with a "messages" array.');
+}
+function parseSpecs(raw) {
+    const trimmed = raw.trim();
+    try {
+        const data = JSON.parse(trimmed);
+        if (Array.isArray(data) && data.length > 0 && data[0]?.role)
+            return [{ messages: data }];
+        if (Array.isArray(data))
+            return data.map(normalizeSpec);
+        return [normalizeSpec(data)];
+    }
+    catch {
+        // fall through to JSONL parsing
+    }
+    const specs = [];
+    for (const line of trimmed.split(/\r?\n/)) {
+        const l = line.trim();
+        if (l)
+            specs.push(normalizeSpec(JSON.parse(l)));
+    }
+    return specs;
+}
+class BatchSubmit extends base_1.BaseCommand {
+    static description = 'Submit offline batch job(s) from a JSON/JSONL file (one conversation per job).';
+    static examples = ['<%= config.bin %> batch submit jobs.jsonl --auto-start'];
+    static args = {
+        file: core_1.Args.string({ description: 'Path to a .json or .jsonl file of jobs', required: true }),
+    };
+    static flags = {
+        model: core_1.Flags.string({ description: 'Default model/alias for jobs that omit one' }),
+        'auto-start': core_1.Flags.boolean({ description: 'Run jobs immediately after submitting' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(BatchSubmit);
+        this.requireToken(flags);
+        let specs;
+        try {
+            specs = parseSpecs((0, node_fs_1.readFileSync)(args.file, 'utf8'));
+        }
+        catch (err) {
+            return this.error(`Invalid batch file: ${err?.message ?? err}`, { exit: 2 });
+        }
+        if (!specs.length)
+            return this.error('No job specs found in file.', { exit: 2 });
+        const api = this.api(flags);
+        const created = [];
+        for (const spec of specs) {
+            const body = { messages: spec.messages, auto_start: Boolean(flags['auto-start']) };
+            if (spec.model || flags.model)
+                body.model = spec.model || flags.model;
+            // sequential on purpose: keeps ordering stable and surfaces the first failure clearly
+            // eslint-disable-next-line no-await-in-loop
+            const res = await api.batchSubmit(body);
+            created.push(res.job ?? res);
+        }
+        if (this.jsonEnabled())
+            return created;
+        this.log((0, output_1.renderTable)(['Job ID', 'Status', 'Model'], created.map((j) => [j.id, j.status, j.model])));
+        return created;
+    }
+}
+exports.default = BatchSubmit;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from '../base';
+export default class Doctor extends BaseCommand {
+    static description: string;
+    run(): Promise<unknown>;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const credentials_1 = require("../lib/credentials");
+class Doctor extends base_1.BaseCommand {
+    static description = 'Check connectivity, auth, provider, and gateway health in one shot.';
+    async run() {
+        const { flags } = await this.parse(Doctor);
+        const profile = this.profileFrom(flags);
+        const api = this.api(flags);
+        const checks = [];
+        const base = this.baseUrlFrom(flags);
+        checks.push({ name: 'API base URL', ok: true, detail: base });
+        try {
+            const h = await api.health();
+            checks.push({ name: 'API reachable', ok: true, detail: String(h.status ?? 'ok') });
+        }
+        catch (err) {
+            checks.push({ name: 'API reachable', ok: false, detail: err?.message ?? 'unreachable' });
+        }
+        const token = (0, credentials_1.getToken)(profile);
+        if (token) {
+            try {
+                const me = await api.me();
+                checks.push({ name: 'Authenticated', ok: true, detail: `${me.user?.email} / ${me.org?.name}` });
+            }
+            catch (err) {
+                checks.push({ name: 'Authenticated', ok: false, detail: err?.message ?? 'invalid token' });
+            }
+            try {
+                const p = await api.providersList();
+                const n = (p.connections ?? p ?? []).length;
+                checks.push({ name: 'Provider configured', ok: n > 0, detail: `${n} connection(s)` });
+            }
+            catch (err) {
+                checks.push({ name: 'Provider configured', ok: false, detail: err?.message ?? 'error' });
+            }
+        }
+        else {
+            checks.push({ name: 'Authenticated', ok: false, detail: 'no token — run `byte login`' });
+        }
+        const key = (0, credentials_1.getByteKey)(profile);
+        if (key) {
+            try {
+                await api.models(key);
+                checks.push({ name: 'Gateway key valid', ok: true, detail: 'byte key accepted' });
+            }
+            catch (err) {
+                checks.push({ name: 'Gateway key valid', ok: err?.status !== 401, detail: err?.message ?? 'error' });
+            }
+        }
+        else {
+            checks.push({ name: 'Gateway key', ok: false, detail: 'no Byte key — run `byte keys create`' });
+        }
+        const healthy = checks.every((c) => c.ok);
+        if (!this.jsonEnabled()) {
+            for (const c of checks)
+                this.log(`${c.ok ? 'OK  ' : 'FAIL'} ${c.name}: ${c.detail}`);
+        }
+        if (!healthy)
+            process.exitCode = 4;
+        return { healthy, checks };
+    }
+}
+exports.default = Doctor;

package/dist/commands/env.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../base';
+export default class Env extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        shell: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sdk: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/env.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const shell_1 = require("../lib/shell");
+class Env extends base_1.BaseCommand {
+    static description = 'Print shell environment exports that point an SDK or tool at Byte.';
+    static examples = [
+        'eval "$(<%= config.bin %> env)"',
+        '<%= config.bin %> env --sdk anthropic --shell powershell',
+    ];
+    static flags = {
+        shell: core_1.Flags.string({ description: 'Shell syntax', options: ['bash', 'zsh', 'fish', 'powershell', 'cmd'] }),
+        sdk: core_1.Flags.string({ description: 'Target SDK', options: ['openai', 'anthropic'], default: 'openai' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Env);
+        const key = this.requireByteKey(flags);
+        const base = this.baseUrlFrom(flags);
+        const shell = (0, shell_1.detectShell)(flags.shell);
+        const vars = flags.sdk === 'anthropic'
+            ? [
+                ['ANTHROPIC_BASE_URL', base],
+                ['ANTHROPIC_AUTH_TOKEN', key],
+            ]
+            : [
+                ['OPENAI_BASE_URL', `${base}/v1`],
+                ['OPENAI_API_KEY', key],
+            ];
+        if (!this.jsonEnabled())
+            this.log((0, shell_1.formatEnvBlock)(shell, vars));
+        return { shell, sdk: flags.sdk, vars: Object.fromEntries(vars) };
+    }
+}
+exports.default = Env;

package/dist/commands/init.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../base';
+export default class Init extends BaseCommand {
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        'provider-key': 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>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/init.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const credentials_1 = require("../lib/credentials");
+const util_1 = require("../lib/util");
+class Init extends base_1.BaseCommand {
+    static description = 'Guided setup: add a provider key, choose a preset, and create your Byte API key.';
+    static aliases = ['onboard'];
+    static flags = {
+        'provider-key': core_1.Flags.string({ description: 'Upstream provider API key (BYOK)', env: 'BYTE_PROVIDER_KEY' }),
+        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 API key', default: 'cli' }),
+        'skip-provider': core_1.Flags.boolean({ description: 'Skip adding a provider key' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        this.requireToken(flags);
+        const profile = this.profileFrom(flags);
+        const api = this.api(flags);
+        const json = this.jsonEnabled();
+        let providerKey = flags['provider-key'];
+        if (!providerKey && !flags['skip-provider'] && !json && process.stdin.isTTY) {
+            providerKey = await (0, util_1.promptHidden)('Upstream provider API key (leave blank to skip): ');
+        }
+        let imported = 0;
+        if (providerKey) {
+            const conn = await api.providersAdd({ api_key: providerKey, gateway_mode: 'byte_auto', auto_fetch: true });
+            imported = conn.fetch_result?.imported ?? conn.imported ?? 0;
+            if (!json)
+                this.log(`Provider connected — ${imported} model(s) imported.`);
+        }
+        else if (!json) {
+            this.log('No provider key added (add one later with `byte providers add`).');
+        }
+        await api.optPatch({ default_mode: flags.preset });
+        if (!json)
+            this.log(`Optimization preset set to "${flags.preset}".`);
+        const keyRes = await api.keysCreate({ name: flags['key-name'], preset: flags.preset });
+        (0, credentials_1.setByteKey)(profile, keyRes.key);
+        if (!json) {
+            this.log('');
+            this.log('Byte API key created and saved to this profile:');
+            this.log(`  ${keyRes.key}`);
+            this.log('');
+            this.log('Next:');
+            this.log('  byte integrate codex          # or claude-code, cursor, cline, aider, openai, anthropic');
+            this.log('  byte run "hello from byte"');
+            this.log('  byte usage');
+        }
+        return { provider_models_imported: imported, preset: flags.preset, byte_key: keyRes.key };
+    }
+}
+exports.default = Init;

package/dist/commands/integrate.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../base';
+export default class Integrate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        target: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        list: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        shell: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        write: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        key: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        preset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+    private writeSettings;
+    private messagesEndpointExists;
+    private showList;
+}

package/dist/commands/integrate.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const base_1 = require("../base");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const integrations_1 = require("../lib/integrations");
+const shell_1 = require("../lib/shell");
+class Integrate extends base_1.BaseCommand {
+    static description = 'Wire a coding harness or SDK to Byte (Claude Code, Codex, Cursor, Cline, Aider, OpenAI/Anthropic SDK).';
+    static examples = [
+        '<%= config.bin %> integrate --list',
+        '<%= config.bin %> integrate codex',
+        '<%= config.bin %> integrate claude-code --write --preset lowest_latency',
+    ];
+    static args = {
+        target: core_1.Args.string({ description: 'Target to wire (run --list to see all)', required: false }),
+    };
+    static flags = {
+        list: core_1.Flags.boolean({ description: 'List supported targets and live readiness' }),
+        shell: core_1.Flags.string({ description: 'Shell syntax for env output', options: ['bash', 'zsh', 'fish', 'powershell', 'cmd'] }),
+        write: core_1.Flags.boolean({ description: 'Write tool config files (a timestamped .bak is kept)' }),
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompts' }),
+        key: core_1.Flags.string({ description: 'Byte API key to use (defaults to the saved profile key)' }),
+        preset: core_1.Flags.string({
+            description: 'Apply this optimization preset to the org before wiring',
+            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Integrate);
+        if (flags.list || !args.target) {
+            return this.showList(flags);
+        }
+        const integ = (0, integrations_1.findIntegration)(args.target);
+        if (!integ) {
+            return this.error(`Unknown target "${args.target}". Run \`byte integrate --list\`.`, { exit: 2 });
+        }
+        const byteKey = flags.key || this.requireByteKey(flags);
+        const base = this.baseUrlFrom(flags);
+        const shell = (0, shell_1.detectShell)(flags.shell);
+        if (flags.preset) {
+            this.requireToken(flags);
+            await this.api(flags).optPatch({ default_mode: flags.preset });
+        }
+        if (integ.compat === 'anthropic') {
+            const exists = await this.messagesEndpointExists(base, byteKey);
+            if (!exists) {
+                this.warn(`${integ.title} needs Byte's Anthropic endpoint (/v1/messages), which did not respond. ` +
+                    'The values below are correct once it is enabled on your gateway.');
+            }
+        }
+        const result = integ.build({ baseUrl: base, byteKey });
+        if (!this.jsonEnabled()) {
+            this.log(`Integrating ${integ.title} (${integ.compat}-compatible):`);
+            this.log('');
+            for (const line of result.instructions)
+                this.log(`  ${line}`);
+            if (result.env.length) {
+                this.log('');
+                this.log('  Environment:');
+                for (const line of (0, shell_1.formatEnvBlock)(shell, result.env).split('\n'))
+                    this.log(`    ${line}`);
+            }
+            if (result.settingsFile) {
+                if (flags.write) {
+                    this.writeSettings(result.settingsFile);
+                }
+                else {
+                    this.log('');
+                    this.log(`  Tip: re-run with --write to update ${result.settingsFile.path} automatically.`);
+                }
+            }
+        }
+        else if (flags.write && result.settingsFile) {
+            this.writeSettings(result.settingsFile);
+        }
+        return { target: integ.key, compat: integ.compat, env: Object.fromEntries(result.env) };
+    }
+    writeSettings(file) {
+        let existing = {};
+        if ((0, node_fs_1.existsSync)(file.path)) {
+            try {
+                existing = JSON.parse((0, node_fs_1.readFileSync)(file.path, 'utf8'));
+            }
+            catch {
+                existing = {};
+            }
+            const backup = `${file.path}.byte-bak-${Date.now()}`;
+            (0, node_fs_1.copyFileSync)(file.path, backup);
+            this.log(`  Backed up existing config to ${backup}`);
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file.path), { recursive: true });
+        (0, node_fs_1.writeFileSync)(file.path, `${JSON.stringify(file.apply(existing), null, 2)}\n`);
+        this.log(`  Updated ${file.path}`);
+    }
+    async messagesEndpointExists(base, byteKey) {
+        try {
+            await new api_1.ByteApi(base).probeMessages(byteKey);
+            return true;
+        }
+        catch (err) {
+            // 404 means the endpoint is not deployed; any other status means it exists.
+            if (err instanceof errors_1.ByteError)
+                return err.status !== 404;
+            return false;
+        }
+    }
+    async showList(flags) {
+        const targets = (0, integrations_1.listIntegrations)();
+        const key = flags.key || this.optionalByteKey(flags);
+        let messagesReady;
+        if (key) {
+            messagesReady = await this.messagesEndpointExists(this.baseUrlFrom(flags), key);
+        }
+        const rows = targets.map((t) => ({
+            target: t.key,
+            title: t.title,
+            compat: t.compat,
+            ready: t.compat === 'openai' ? true : messagesReady,
+        }));
+        if (this.jsonEnabled())
+            return rows;
+        for (const r of rows) {
+            const status = r.ready === undefined ? 'unknown (sign in / create a key to probe)' : r.ready ? 'ready' : 'needs /v1/messages';
+            this.log(`${r.target.padEnd(14)} ${r.title.padEnd(16)} ${r.compat.padEnd(10)} ${status}`);
+        }
+        return rows;
+    }
+}
+exports.default = Integrate;

package/dist/commands/keys/create.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class KeysCreate extends BaseCommand {
+    static description: string;
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        preset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/keys/create.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class KeysCreate extends base_1.BaseCommand {
+    static description = 'Create a new Byte API key. The secret is shown only once.';
+    static args = {
+        name: core_1.Args.string({ description: 'A label for the key (e.g. prod-chat)', required: true }),
+    };
+    static flags = {
+        preset: core_1.Flags.string({
+            description: 'Bind a default optimization preset to this key',
+            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first', 'manual'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysCreate);
+        this.requireToken(flags);
+        const body = { name: args.name };
+        if (flags.preset)
+            body.preset = flags.preset;
+        const res = await this.api(flags).keysCreate(body);
+        if (!this.jsonEnabled()) {
+            this.log(`Created key "${res.record?.name}" (id ${res.record?.id}).`);
+            this.log('');
+            this.log(`  ${res.key}`);
+            this.log('');
+            this.log('Copy it now — it will not be shown again.');
+        }
+        return res;
+    }
+}
+exports.default = KeysCreate;

package/dist/commands/keys/list.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from '../../base';
+export default class KeysList extends BaseCommand {
+    static description: string;
+    run(): Promise<unknown>;
+}