@bytevion/cli 0.4.1 → 0.5.0

package/dist/commands/connect.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../base';
+export default class Connect extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        model: 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>;
+        only: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/connect.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const detect_1 = require("../lib/detect");
+class Connect extends base_1.BaseCommand {
+    static description = 'Detect installed coding agents and wire every one Byte can auto-configure — in one shot.';
+    static examples = [
+        '<%= config.bin %> connect',
+        '<%= config.bin %> connect --model byte-2-deepseek-v4-flash',
+        '<%= config.bin %> connect --only opencode,codex',
+    ];
+    static flags = {
+        model: core_1.Flags.string({ description: 'Model id (byte alias) to wire (default byte-default)' }),
+        preset: core_1.Flags.string({
+            description: 'Optimization preset to apply before wiring',
+            options: ['maximum', 'balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+        }),
+        only: core_1.Flags.string({ description: 'Comma-separated subset of tool keys to wire' }),
+        yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompts' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Connect);
+        // A Byte key is what gets written into each tool's config, so require one up front.
+        this.requireByteKey(flags);
+        const only = flags.only ? new Set(flags.only.split(',').map((s) => s.trim()).filter(Boolean)) : null;
+        const detected = (0, detect_1.detectTools)().filter((d) => d.installed && (!only || only.has(d.key)));
+        const targets = detected.filter((d) => d.canAutoWrite);
+        const manual = detected.filter((d) => !d.canAutoWrite).map((d) => d.key);
+        if (!targets.length) {
+            if (!this.jsonEnabled()) {
+                this.log('No auto-configurable coding agents detected.');
+                if (manual.length)
+                    this.log(`Installed but manual: ${manual.join(', ')} — run \`byte integrate <tool>\`.`);
+                else
+                    this.log('Install one (e.g. opencode) or wire manually with `byte integrate --list`.');
+            }
+            return { wired: [], manual };
+        }
+        const wired = [];
+        for (const target of targets) {
+            const argv = [
+                target.key,
+                '--write',
+                '--yes',
+                ...(flags.model ? ['--model', flags.model] : []),
+                ...(flags.preset ? ['--preset', flags.preset] : []),
+            ];
+            // sequential keeps config writes + their backups ordered and surfaces the first failure clearly
+            // eslint-disable-next-line no-await-in-loop
+            await this.config.runCommand('integrate', argv);
+            wired.push(target.key);
+        }
+        if (!this.jsonEnabled()) {
+            this.log('');
+            this.log(`Connected ${wired.length} tool(s): ${wired.join(', ')}.`);
+            if (manual.length)
+                this.log(`Manual setup needed for: ${manual.join(', ')} — run \`byte integrate <tool>\`.`);
+            this.log('Export the Byte key in your shell (see `byte env`) and start coding.');
+        }
+        return { wired, manual };
+    }
+}
+exports.default = Connect;

package/dist/commands/dash.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base';
+export default class Dash extends BaseCommand {
+    static description: string;
+    static aliases: string[];
+    run(): Promise<unknown>;
+    private emptyDash;
+    private loadDash;
+    private renderText;
+}

package/dist/commands/dash.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const config_1 = require("../lib/config");
+const tui_1 = require("../lib/tui");
+class Dash extends base_1.BaseCommand {
+    static description = 'Live terminal dashboard: savings, recent requests, optimizations, and gateway health.';
+    static aliases = ['monitor', 'top'];
+    async run() {
+        const { flags } = await this.parse(Dash);
+        const load = () => this.loadDash(flags);
+        let data;
+        try {
+            data = await load();
+        }
+        catch {
+            data = this.emptyDash();
+        }
+        if ((0, tui_1.useInk)({ json: this.jsonEnabled() })) {
+            const res = await (0, tui_1.renderDashIsland)({
+                data,
+                ports: {
+                    refresh: async () => {
+                        try {
+                            return await load();
+                        }
+                        catch {
+                            return data;
+                        }
+                    },
+                },
+                ascii: (0, tui_1.computeAscii)(),
+                plainColor: Boolean(process.env.NO_COLOR),
+                version: this.config.version,
+            });
+            if (res.status !== 'fallback')
+                return data;
+        }
+        if (this.jsonEnabled())
+            return data;
+        this.log(this.renderText(data));
+        return data;
+    }
+    emptyDash() {
+        return { gateway: 'unknown', requests: 0, cacheHitRate: 0, savedTotal: 0, tokensTotal: 0, costTotal: 0, savingsSeries: [], providers: 0, models: 0, recent: [], layers: [] };
+    }
+    async loadDash(flags) {
+        const api = this.api(flags);
+        const out = this.emptyDash();
+        const settle = async (p) => {
+            try {
+                return await p;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const [summary, usage, opt, reqs, health] = await Promise.all([
+            settle(api.dashboard()),
+            settle(api.usage('day')),
+            settle(api.optShow()),
+            settle(api.requests()),
+            settle(api.health()),
+        ]);
+        const s = summary ?? {};
+        out.requests = Number(s.total_requests ?? s.requests ?? 0);
+        out.savedTotal = Number(s.total_savings_usd ?? s.savings_usd ?? 0);
+        out.costTotal = Number(s.byte_cost_usd ?? s.cost_usd ?? 0);
+        out.tokensTotal = Number(s.total_tokens ?? s.tokens ?? 0);
+        out.providers = Number(s.providers ?? s.connections ?? 0);
+        out.models = Number(s.models ?? s.enabled_models ?? 0);
+        try {
+            out.email = (0, config_1.getProfile)(this.profileFrom(flags)).email;
+        }
+        catch {
+            out.email = undefined;
+        }
+        const h = health ?? {};
+        out.gateway = h.status === 'ready' || h.status === 'ok' ? 'healthy' : h.status ? 'down' : 'unknown';
+        const buckets = Array.isArray(usage?.buckets) ? usage.buckets : Array.isArray(usage) ? usage : [];
+        out.savingsSeries = buckets.map((b) => Number(b.savings_usd ?? b.savings ?? 0));
+        const totalReq = buckets.reduce((n, b) => n + Number(b.requests ?? 0), 0);
+        const cached = buckets.reduce((n, b) => n + Number(b.cached ?? b.cache_hits ?? 0), 0);
+        let hitRate = totalReq ? cached / totalReq : Number(s.cache_hit_rate ?? s.cache_hit_rate_pct ?? 0);
+        if (hitRate > 1)
+            hitRate = hitRate / 100; // some summaries report a percentage, not a fraction
+        out.cacheHitRate = Math.max(0, Math.min(1, hitRate));
+        if (!out.requests && totalReq)
+            out.requests = totalReq;
+        const o = opt ?? {};
+        out.mode = String(o.summary?.default_mode ?? o.settings?.default_mode ?? o.default_mode ?? 'maximum');
+        const layers = Array.isArray(o.layers) ? o.layers : [];
+        out.layers = layers.map((l) => ({ label: String(l.plain_label ?? l.label ?? l.key ?? 'layer'), active: Boolean(l.enabled ?? l.active ?? l.status === 'active') }));
+        const list = Array.isArray(reqs?.requests) ? reqs.requests : Array.isArray(reqs) ? reqs : [];
+        out.recent = list.slice(0, 8).map((r) => ({
+            model: String(r.model ?? r.selected_alias ?? r.routed_model ?? r.alias ?? '—'),
+            status: String(r.status ?? 'ok'),
+            latencyMs: Number(r.total_latency_ms ?? r.latency_ms ?? 0),
+            tokens: Number(r.tokens_in ?? 0) + Number(r.tokens_out ?? 0) || Number(r.tokens ?? 0),
+            cache: r.cache_hit ? String(r.cache_hit_type ?? 'hit') : '',
+        }));
+        if (!out.tokensTotal)
+            out.tokensTotal = out.recent.reduce((n, r) => n + r.tokens, 0);
+        return out;
+    }
+    renderText(d) {
+        const lines = [
+            `byte dash — gateway ${d.gateway}, mode ${d.mode ?? 'maximum'}`,
+            `saved $${d.savedTotal.toFixed(4)} · requests ${d.requests} · cache ${Math.round(d.cacheHitRate * 100)}% · tokens ${d.tokensTotal}`,
+            `optimizations ${d.layers.filter((l) => l.active).length}/${d.layers.length} active · providers ${d.providers} · models ${d.models}`,
+        ];
+        if (d.recent.length) {
+            lines.push('recent:');
+            for (const r of d.recent.slice(0, 8))
+                lines.push(`  ${r.model}  ${r.latencyMs}ms  ${r.tokens}tok  ${r.cache ?? ''}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.default = Dash;

package/dist/commands/integrate.d.ts

@@ -7,6 +7,7 @@ export default class Integrate extends BaseCommand {
     };
     static flags: {
         list: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        status: 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>;
@@ -15,7 +16,9 @@ export default class Integrate extends BaseCommand {
         preset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<unknown>;
+    private recordWiring;
     private writeSettings;
     private messagesEndpointExists;
+    private showStatus;
     private showList;
 }

package/dist/commands/integrate.js

@@ -39,11 +39,14 @@ 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 config_formats_1 = require("../lib/config-formats");
+const detect_1 = require("../lib/detect");
 const integrations_1 = require("../lib/integrations");
 const shell_1 = require("../lib/shell");
 const tty_1 = require("../lib/tty");
 const ui = __importStar(require("../lib/ui"));
 const util_1 = require("../lib/util");
+const wiring_1 = require("../lib/wiring");
 class Integrate extends base_1.BaseCommand {
     static description = 'Wire a coding harness or SDK to Byte (Claude Code, Codex, opencode, Cursor, Cline, Aider, …).';
     static examples = [
@@ -56,6 +59,7 @@ class Integrate extends base_1.BaseCommand {
     };
     static flags = {
         list: core_1.Flags.boolean({ description: 'List supported targets and live readiness' }),
+        status: core_1.Flags.boolean({ description: 'Show installed tools and whether each is wired / unwired / manual' }),
         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' }),
@@ -70,6 +74,8 @@ class Integrate extends base_1.BaseCommand {
         const { args, flags } = await this.parse(Integrate);
         if (flags.list)
             return this.showList(flags);
+        if (flags.status)
+            return this.showStatus(flags);
         let target = args.target;
         if (!target) {
             if ((0, tty_1.interactive)() && !this.jsonEnabled()) {
@@ -112,8 +118,10 @@ class Integrate extends base_1.BaseCommand {
                     this.log(`    ${line}`);
             }
             if (result.settingsFile) {
-                if (flags.write)
-                    this.writeSettings(result.settingsFile);
+                if (flags.write) {
+                    if (this.writeSettings(result.settingsFile))
+                        this.recordWiring(flags, integ.key, modelAlias);
+                }
                 else {
                     this.log('');
                     this.log(`  Tip: re-run with --write to update ${result.settingsFile.path} automatically.`);
@@ -121,26 +129,44 @@ class Integrate extends base_1.BaseCommand {
             }
         }
         else if (flags.write && result.settingsFile) {
-            this.writeSettings(result.settingsFile);
+            if (this.writeSettings(result.settingsFile))
+                this.recordWiring(flags, integ.key, modelAlias);
         }
         return { target: integ.key, compat: integ.compat, model: modelAlias, env: Object.fromEntries(result.env) };
     }
+    // Remember what we wired (and the model) so `byte sync` can re-apply on key/model changes.
+    recordWiring(flags, key, modelAlias) {
+        const profile = this.profileFrom(flags);
+        (0, wiring_1.addWiredTool)(profile, key);
+        (0, wiring_1.setSelectedModel)(profile, modelAlias);
+    }
     writeSettings(file) {
+        const format = file.format ?? 'json';
         let existing = {};
         if ((0, node_fs_1.existsSync)(file.path)) {
             try {
-                existing = JSON.parse((0, node_fs_1.readFileSync)(file.path, 'utf8'));
+                existing = (0, config_formats_1.parseConfig)(format, (0, node_fs_1.readFileSync)(file.path, 'utf8'));
             }
             catch {
-                existing = {};
+                this.warn(`  Could not parse ${file.path} as ${format} — leaving it unchanged. Use the manual steps above.`);
+                return false;
             }
             const backup = `${file.path}.byte-bak-${Date.now()}`;
             (0, node_fs_1.copyFileSync)(file.path, backup);
             this.log(`  Backed up existing config to ${backup}`);
         }
+        let serialized;
+        try {
+            serialized = (0, config_formats_1.stringifyConfig)(format, file.apply(existing));
+        }
+        catch {
+            this.warn(`  Could not render ${file.path} as ${format} — use the manual steps above.`);
+            return false;
+        }
         (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`);
+        (0, node_fs_1.writeFileSync)(file.path, serialized);
         this.log(`  Updated ${file.path}`);
+        return true;
     }
     async messagesEndpointExists(base, byteKey) {
         const probe = (async () => {
@@ -157,6 +183,32 @@ class Integrate extends base_1.BaseCommand {
         // Never block the UX on a slow gateway; assume reachable on timeout.
         return (0, util_1.withTimeout)(probe, 4000, true);
     }
+    // Auto-detect installed agents and report each as wired / unwired / manual / not-installed,
+    // so a user can see at a glance what `byte connect` will (or did) configure.
+    async showStatus(flags) {
+        const base = this.baseUrlFrom(flags);
+        const byteKey = this.optionalByteKey(flags) || '';
+        const rows = (0, detect_1.detectTools)().map((d) => {
+            let wired = false;
+            const integ = (0, integrations_1.findIntegration)(d.key);
+            const file = integ?.build({ baseUrl: base, byteKey, modelAlias: 'byte-default' }).settingsFile;
+            if (file && (0, node_fs_1.existsSync)(file.path)) {
+                try {
+                    wired = (0, node_fs_1.readFileSync)(file.path, 'utf8').toLowerCase().includes('byte');
+                }
+                catch {
+                    wired = false;
+                }
+            }
+            const state = !d.installed ? 'not-installed' : !d.canAutoWrite ? 'manual' : wired ? 'wired' : 'unwired';
+            return { target: d.key, title: d.title, installed: d.installed, state };
+        });
+        if (this.jsonEnabled())
+            return rows;
+        for (const r of rows)
+            this.log(`${r.target.padEnd(16)} ${r.title.padEnd(22)} ${r.state}`);
+        return rows;
+    }
     async showList(flags) {
         const targets = (0, integrations_1.listIntegrations)();
         const key = flags.key || this.optionalByteKey(flags);

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

@@ -7,5 +7,8 @@ export default class KeysRotate extends BaseCommand {
             min?: number;
         }>;
     };
+    static flags: {
+        sync: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<unknown>;
 }

package/dist/commands/keys/rotate.js

@@ -2,21 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
+const credentials_1 = require("../../lib/credentials");
 class KeysRotate extends base_1.BaseCommand {
     static description = 'Rotate a Byte API key: issue a new secret and invalidate the old one.';
     static args = {
         id: core_1.Args.integer({ description: 'Key id (see `byte keys list`)', required: true }),
     };
+    static flags = {
+        sync: core_1.Flags.boolean({ description: 'Save the new secret to this profile and re-apply it to all wired tools (`byte sync`)' }),
+    };
     async run() {
         const { args, flags } = await this.parse(KeysRotate);
         this.requireToken(flags);
         const res = await this.api(flags).keysRotate(args.id);
+        if (flags.sync && res?.key) {
+            (0, credentials_1.setByteKey)(this.profileFrom(flags), String(res.key));
+            await this.config.runCommand('sync', ['--yes']);
+        }
         if (!this.jsonEnabled()) {
             this.log(`Rotated key ${args.id}. New secret (shown once):`);
             this.log('');
             this.log(`  ${res.key}`);
             this.log('');
-            this.log('Update any integration that used the old secret (e.g. re-run `byte integrate`).');
+            this.log(flags.sync ? 'Saved to this profile and re-synced all wired tools.' : 'Update any integration that used the old secret — or run `byte keys` then `byte sync`.');
         }
         return res;
     }

package/dist/commands/mcp/add.d.ts

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

package/dist/commands/mcp/add.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class McpAdd extends base_1.BaseCommand {
+    static description = 'Register an MCP server for Byte to host — its tools become available to your models (namespaced mcp__<name>__*).';
+    static examples = ['<%= config.bin %> mcp add filesystem --url https://mcp.example.com/rpc'];
+    static args = {
+        name: core_1.Args.string({ description: 'Short name (namespaces the tools)', required: true }),
+    };
+    static flags = {
+        url: core_1.Flags.string({ description: 'MCP server URL (streamable HTTP)', required: true }),
+        header: core_1.Flags.string({ description: 'Auth header as KEY:VALUE (repeatable)', multiple: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(McpAdd);
+        this.requireToken(flags);
+        const headers = {};
+        for (const entry of flags.header ?? []) {
+            const idx = entry.indexOf(':');
+            if (idx > 0)
+                headers[entry.slice(0, idx).trim()] = entry.slice(idx + 1).trim();
+        }
+        const res = await this.api(flags).mcpAdd({ name: args.name, url: flags.url, headers });
+        if (this.jsonEnabled())
+            return res;
+        this.log(`Registered MCP server "${res.name}" (id ${res.id}). Verify it with \`byte mcp test ${res.id}\`.`);
+        return res;
+    }
+}
+exports.default = McpAdd;

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

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

package/dist/commands/mcp/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 McpList extends base_1.BaseCommand {
+    static description = 'List the MCP servers registered for this org.';
+    async run() {
+        const { flags } = await this.parse(McpList);
+        this.requireToken(flags);
+        const res = await this.api(flags).mcpServers();
+        const servers = res.servers ?? [];
+        if (this.jsonEnabled())
+            return servers;
+        if (!servers.length) {
+            this.log('No MCP servers registered. Add one with `byte mcp add <name> --url ...`.');
+            return servers;
+        }
+        this.log((0, output_1.renderTable)(['ID', 'Name', 'URL', 'Transport', 'Enabled'], servers.map((s) => [String(s.id), s.name, s.url, s.transport, s.enabled ? 'yes' : 'no'])));
+        return servers;
+    }
+}
+exports.default = McpList;

package/dist/commands/mcp/remove.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class McpRemove extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/mcp/remove.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class McpRemove extends base_1.BaseCommand {
+    static description = 'Remove a registered MCP server.';
+    static args = {
+        id: core_1.Args.integer({ description: 'Server id (see `byte mcp list`)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(McpRemove);
+        this.requireToken(flags);
+        await this.api(flags).mcpRemove(args.id);
+        if (!this.jsonEnabled())
+            this.log(`Removed MCP server ${args.id}.`);
+        return { status: 'removed', id: args.id };
+    }
+}
+exports.default = McpRemove;

package/dist/commands/mcp/test.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class McpTest extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/mcp/test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class McpTest extends base_1.BaseCommand {
+    static description = 'Verify a registered MCP server by listing the tools it exposes.';
+    static args = {
+        id: core_1.Args.integer({ description: 'Server id (see `byte mcp list`)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(McpTest);
+        this.requireToken(flags);
+        const res = await this.api(flags).mcpTest(args.id);
+        if (this.jsonEnabled())
+            return res;
+        this.log(`MCP server ${args.id} reachable — ${res.tools} tool(s): ${(res.tool_names ?? []).join(', ')}`);
+        return res;
+    }
+}
+exports.default = McpTest;

package/dist/commands/providers/compare.d.ts

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

package/dist/commands/providers/compare.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class ProvidersCompare extends base_1.BaseCommand {
+    static description = 'Enable (or disable) direct-vs-Byte comparison on imported models. Run with --all so `byte compare` works out of the box.';
+    static examples = [
+        '<%= config.bin %> providers compare --all',
+        '<%= config.bin %> providers compare byte-2-deepseek-v4-flash',
+        '<%= config.bin %> providers compare byte-2-deepseek-v4-flash --off',
+    ];
+    static args = {
+        alias: core_1.Args.string({ description: 'Model byte alias (omit when using --all)', required: false }),
+    };
+    static flags = {
+        all: core_1.Flags.boolean({ description: 'Apply to every priced model in the org' }),
+        off: core_1.Flags.boolean({ description: 'Disable comparison instead of enabling it' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersCompare);
+        this.requireToken(flags);
+        const api = this.api(flags);
+        const on = !flags.off;
+        const res = await api.modelsList();
+        const list = Array.isArray(res) ? res : res?.models ?? [];
+        let targets;
+        if (flags.all)
+            targets = list.filter((m) => m.pricing_status === 'verified' || m.input_price_per_million);
+        else if (args.alias)
+            targets = list.filter((m) => m.byte_alias === args.alias);
+        else
+            return this.error('Pass a model alias or --all. See `byte providers list`.', { exit: 2 });
+        if (!targets.length) {
+            return this.error(args.alias ? `No model with alias "${args.alias}".` : 'No priced models found to enable.', { exit: 2 });
+        }
+        for (const model of targets) {
+            // sequential keeps ordering stable and surfaces the first failure clearly
+            // eslint-disable-next-line no-await-in-loop
+            await api.modelCompare(model.id, on);
+        }
+        const verb = on ? 'enabled' : 'disabled';
+        const aliases = targets.map((m) => m.byte_alias);
+        if (this.jsonEnabled())
+            return { compare: verb, models: aliases };
+        this.log(`Comparison ${verb} on: ${aliases.join(', ')}`);
+        if (on && targets.length < 2 && !flags.all) {
+            this.log('Tip: `byte compare` (auto) needs 2+ models with comparison enabled — re-run with --all.');
+        }
+        return { compare: verb, models: aliases };
+    }
+}
+exports.default = ProvidersCompare;

package/dist/commands/sync.d.ts

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