@bytevion/cli 0.5.0 → 0.5.2

package/dist/commands/compare.js

@@ -41,6 +41,42 @@ const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : Number(v)
 const usd = (v) => `$${num(v).toFixed(6)}`;
 const tokensOf = (m) => num(m?.tokens_in) + num(m?.tokens_out);
 const pad = (s, n) => s.padEnd(n);
+const QUALITY_PASS = new Set(['quality_held', 'quality_improved', 'passed_verification']);
+// The gateway scores each lane's quality in isolation; a soft "failed_verification" means
+// an automated claim check was inconclusive, not that the answer is wrong or worse than
+// direct. Render it as unverified rather than a scary raw state.
+const qualityLabel = (s) => {
+    switch (s) {
+        case 'quality_held':
+        case 'quality_improved':
+        case 'passed_verification':
+            return 'held';
+        case 'failed_verification':
+            return 'unverified (auto-check inconclusive)';
+        case 'review':
+            return 'needs review';
+        case 'failed_guard':
+            return 'failed — output unusable';
+        case 'not_measured':
+            return 'not measured';
+        default:
+            return s;
+    }
+};
+const verdictLine = (dominance, quality, savingsPct, latencySaved) => {
+    const cheaper = savingsPct > 0;
+    const faster = latencySaved > 0;
+    const held = QUALITY_PASS.has(quality);
+    if (dominance === 'dominant')
+        return ui.theme.ok('Byte wins — cheaper, faster, quality held');
+    if (dominance === 'regressed')
+        return ui.theme.bad('Regressed — direct was the better choice here');
+    if (cheaper || faster) {
+        const wins = [cheaper ? `${savingsPct.toFixed(0)}% cheaper` : '', faster ? `${Math.abs(latencySaved)}ms faster` : ''].filter(Boolean).join(', ');
+        return ui.theme.ok(`Byte wins — ${wins}`) + (held ? '' : ui.theme.muted(' · quality unverified'));
+    }
+    return ui.theme.muted('Neutral — no clear difference');
+};
 class Compare extends base_1.BaseCommand {
     static description = 'Prove the win: run a prompt direct vs through Byte and compare cost, latency, and quality.';
     static examples = [
@@ -94,9 +130,8 @@ class Compare extends base_1.BaseCommand {
         const sign = latencySaved >= 0 ? '−' : '+';
         this.log(`  Savings    ${usd(savings)} (${savingsPct.toFixed(1)}%)`);
         this.log(`  Latency    ${sign}${Math.abs(latencySaved)} ms`);
-        this.log(`  Quality    ${quality}`);
-        const verdict = dominance === 'dominant' ? ui.theme.ok('Byte wins (dominant)') : ui.theme.warn(dominance);
-        this.log(`  Verdict    ${verdict}`);
+        this.log(`  Quality    ${qualityLabel(quality)}`);
+        this.log(`  Verdict    ${verdictLine(dominance, quality, savingsPct, latencySaved)}`);
         this.log('');
         return { direct, byte, summary };
     }

package/dist/commands/connect.d.ts

@@ -6,7 +6,10 @@ export default class Connect extends BaseCommand {
         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>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        write: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<unknown>;
+    private smokeTest;
 }

package/dist/commands/connect.js

@@ -7,22 +7,26 @@ 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 --all --write',
         '<%= config.bin %> connect --only opencode,codex',
     ];
     static flags = {
-        model: core_1.Flags.string({ description: 'Model id (byte alias) to wire (default byte-default)' }),
+        model: core_1.Flags.string({ description: 'Model to wire (default: auto — Byte routes to your enabled model)' }),
         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' }),
+        all: core_1.Flags.boolean({ description: 'Wire every detected auto-configurable tool (this is the default)' }),
+        write: core_1.Flags.boolean({ description: 'Write tool config files (the default for connect)' }),
         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 byteKey = this.requireByteKey(flags);
+        const model = flags.model || 'auto';
+        const bin = this.config.bin;
         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);
@@ -31,34 +35,61 @@ class Connect extends base_1.BaseCommand {
             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>\`.`);
+                    this.log(`Installed but manual: ${manual.join(', ')} — run \`${bin} integrate <tool>\`.`);
                 else
-                    this.log('Install one (e.g. opencode) or wire manually with `byte integrate --list`.');
+                    this.log(`Install one (e.g. opencode) or wire manually with \`${bin} 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] : []),
-            ];
+            const argv = [target.key, '--write', '--yes', '--model', 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.');
+        // Real smoke test of the shared gateway every config points at: list models, then send a
+        // model=auto completion. Only claim "connected" if both pass.
+        const probe = await this.smokeTest(byteKey, flags);
+        if (this.jsonEnabled())
+            return { wired, manual, model, verified: probe.ok, probe };
+        this.log('');
+        if (probe.ok) {
+            this.log(`Connected ${wired.length} tool(s): ${wired.join(', ')}  ✓ gateway verified (model: ${model}).`);
+        }
+        else {
+            this.log(`Wired ${wired.length} tool(s): ${wired.join(', ')} — gateway smoke test did not pass: ${probe.reason}.`);
+            this.log(`Resolve that, then confirm with \`${bin} run "hi"\` or \`${bin} doctor\`.`);
+        }
+        if (manual.length)
+            this.log(`Manual setup needed for: ${manual.join(', ')} — run \`${bin} integrate <tool>\`.`);
+        this.log(`Export the Byte key in your shell (see \`${bin} env\`) and start coding.`);
+        return { wired, manual, model, verified: probe.ok };
+    }
+    // GET /v1/models then POST /v1/chat/completions model=auto, both with the Byte key. Returns
+    // a clear reason on failure so connect never prints "connected" for a wiring that won't work.
+    async smokeTest(byteKey, flags) {
+        const api = this.api(flags);
+        try {
+            await api.models(byteKey);
+        }
+        catch (err) {
+            const e = err;
+            return { ok: false, reason: `GET /v1/models failed (${e?.code || e?.message || 'unreachable'})` };
+        }
+        try {
+            const res = (await api.chat(byteKey, { model: 'auto', max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] }));
+            if (res?.choices?.length || res?.id)
+                return { ok: true, reason: '' };
+            return { ok: false, reason: 'chat returned no choices' };
+        }
+        catch (err) {
+            const e = err;
+            const code = String(e?.code || e?.message || 'error');
+            const reason = code.includes('NOT_CONFIGURED') ? `no model enabled yet — run \`${this.config.bin} setup\` or enable a model` : `POST /v1/chat/completions model=auto failed (${code})`;
+            return { ok: false, reason };
         }
-        return { wired, manual };
     }
 }
 exports.default = Connect;

package/dist/commands/integrate.js

@@ -64,7 +64,7 @@ class Integrate extends base_1.BaseCommand {
         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)' }),
-        model: core_1.Flags.string({ description: 'Model id (byte alias) to wire (default byte-default)' }),
+        model: core_1.Flags.string({ description: 'Model to wire (default: auto — Byte routes to your enabled model)' }),
         preset: core_1.Flags.string({
             description: 'Apply this optimization preset to the org before wiring',
             options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
@@ -90,11 +90,11 @@ class Integrate extends base_1.BaseCommand {
         }
         const integ = (0, integrations_1.findIntegration)(target);
         if (!integ)
-            return this.error(`Unknown target "${target}". Run \`byte integrate --list\`.`, { exit: 2 });
+            return this.error(`Unknown target "${target}". Run \`${this.config.bin} integrate --list\`.`, { exit: 2 });
         const byteKey = flags.key || this.requireByteKey(flags);
         const base = this.baseUrlFrom(flags);
         const shell = (0, shell_1.detectShell)(flags.shell);
-        const modelAlias = flags.model || 'byte-default';
+        const modelAlias = flags.model || 'auto';
         if (flags.preset) {
             this.requireToken(flags);
             await this.api(flags).optPatch({ default_mode: flags.preset });
@@ -191,7 +191,7 @@ class Integrate extends base_1.BaseCommand {
         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;
+            const file = integ?.build({ baseUrl: base, byteKey, modelAlias: 'auto' }).settingsFile;
             if (file && (0, node_fs_1.existsSync)(file.path)) {
                 try {
                     wired = (0, node_fs_1.readFileSync)(file.path, 'utf8').toLowerCase().includes('byte');

package/dist/commands/metrics.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base';
+export default class Metrics extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/metrics.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const output_1 = require("../lib/output");
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : Number(v) || 0);
+const pad = (s) => s.padEnd(12);
+class Metrics extends base_1.BaseCommand {
+    static description = 'Full cost / latency / quality breakdown for a single request.';
+    static examples = ['<%= config.bin %> metrics 1429', '<%= config.bin %> requests  # to find an id'];
+    static args = {
+        id: core_1.Args.string({ description: 'Request id (from the requests list or the dashboard)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Metrics);
+        this.requireToken(flags);
+        const d = await this.api(flags).requestDetail(args.id);
+        if (this.jsonEnabled())
+            return d;
+        const cost = d.cost ?? {};
+        const tok = d.tokens ?? {};
+        const lat = d.latency ?? {};
+        const cache = d.cache ?? {};
+        const routedFrom = d.requested_model && d.requested_model !== d.routed_model ? `  (routed from: ${d.requested_model})` : '';
+        const layers = Array.isArray(d.layers) ? d.layers : [];
+        this.log('');
+        this.log(`  ${pad('Model')}${d.routed_model ?? d.selected_alias ?? '-'}${routedFrom}`);
+        this.log(`  ${pad('Cost')}direct ${(0, output_1.fmtUsd)(cost.raw_usd)} → byte ${(0, output_1.fmtUsd)(cost.byte_usd)}   save ${num(cost.savings_pct).toFixed(1)}%`);
+        this.log(`  ${pad('Tokens')}in ${num(tok.in)}  out ${num(tok.out)}${num(tok.cached_in) ? `   (cached in ${num(tok.cached_in)})` : ''}`);
+        this.log(`  ${pad('Latency')}${num(lat.total_ms)}ms  · ttft ${num(lat.ttft_ms)}ms${num(lat.saved_ms) ? `  · saved ${num(lat.saved_ms)}ms` : ''}`);
+        this.log(`  ${pad('Cache')}tier=${cache.layer ?? 'miss'}  · quality=${d.quality_gate_state || 'n/a'}`);
+        if (layers.length)
+            this.log(`  ${pad('Layers')}${layers.map((l) => `${l.layer}(${(0, output_1.fmtUsd)(l.savings_usd)})`).join('  ')}`);
+        this.log(`  ${pad('Verdict')}${d.dominance_status || '-'}`);
+        this.log('');
+        return d;
+    }
+}
+exports.default = Metrics;

package/dist/commands/sync.d.ts

@@ -4,6 +4,7 @@ export default class Sync extends BaseCommand {
     static examples: string[];
     static flags: {
         model: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<unknown>;

package/dist/commands/sync.js

@@ -7,7 +7,8 @@ class Sync extends base_1.BaseCommand {
     static description = 'Re-apply your current Byte key/model to every wired coding agent (run after rotating a key or switching model).';
     static examples = ['<%= config.bin %> sync', '<%= config.bin %> sync --model byte-2-deepseek-v4-flash'];
     static flags = {
-        model: core_1.Flags.string({ description: 'Model id (byte alias) to wire (defaults to the last wired model)' }),
+        model: core_1.Flags.string({ description: 'Model to wire (default: the last wired model, or auto)' }),
+        all: core_1.Flags.boolean({ description: 'Re-apply to every wired tool (this is the default)' }),
         yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompts' }),
     };
     async run() {
@@ -18,10 +19,10 @@ class Sync extends base_1.BaseCommand {
         const tools = wiring.tools || [];
         if (!tools.length) {
             if (!this.jsonEnabled())
-                this.log('No wired tools yet. Run `byte connect` first.');
+                this.log(`No wired tools yet. Run \`${this.config.bin} connect\` first.`);
             return { synced: [] };
         }
-        const model = flags.model || wiring.model;
+        const model = flags.model || wiring.model || 'auto';
         if (flags.model)
             (0, wiring_1.setSelectedModel)(profile, flags.model);
         const synced = [];

package/dist/lib/api.d.ts

@@ -34,6 +34,7 @@ export declare class ByteApi {
     usage(granularity: string): Promise<any>;
     dashboard(): Promise<any>;
     requests(): Promise<any>;
+    requestDetail(id: string | number): Promise<any>;
     cacheStats(): Promise<any>;
     costs(): Promise<any>;
     health(): Promise<any>;

package/dist/lib/api.js

@@ -138,6 +138,9 @@ class ByteApi {
     requests() {
         return this.request('GET', '/api/v1/requests');
     }
+    requestDetail(id) {
+        return this.request('GET', `/api/v1/requests/${encodeURIComponent(String(id))}`);
+    }
     cacheStats() {
         return this.request('GET', '/api/v1/cache/stats');
     }

package/dist/lib/home.js

@@ -68,7 +68,13 @@ async function loadHomeData(api, byteKey, fallbackId) {
         providers: conns.length || undefined,
         models: models || undefined,
         byteKey,
-        gateway: health ? (health.status === 'ok' || health.ok ? 'healthy' : 'down') : 'unknown',
+        // The control plane reports a ready gateway as status:"ready" (and mirrors it in
+        // health.gateway). Accept "ready"/"ok"/ok so a healthy gateway is never shown as down.
+        gateway: health
+            ? health.status === 'ready' || health.status === 'ok' || health.gateway === 'ready' || health.gateway === '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),

package/oclif.manifest.json

@@ -68,7 +68,7 @@
       "description": "Detect installed coding agents and wire every one Byte can auto-configure — in one shot.",
       "examples": [
         "<%= config.bin %> connect",
-        "<%= config.bin %> connect --model byte-2-deepseek-v4-flash",
+        "<%= config.bin %> connect --all --write",
         "<%= config.bin %> connect --only opencode,codex"
       ],
       "flags": {
@@ -96,7 +96,7 @@
           "type": "option"
         },
         "model": {
-          "description": "Model id (byte alias) to wire (default byte-default)",
+          "description": "Model to wire (default: auto — Byte routes to your enabled model)",
           "name": "model",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -123,6 +123,18 @@
           "multiple": false,
           "type": "option"
         },
+        "all": {
+          "description": "Wire every detected auto-configurable tool (this is the default)",
+          "name": "all",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "write": {
+          "description": "Write tool config files (the default for connect)",
+          "name": "write",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "yes": {
           "char": "y",
           "description": "Skip confirmation prompts",
@@ -479,7 +491,7 @@
           "type": "option"
         },
         "model": {
-          "description": "Model id (byte alias) to wire (default byte-default)",
+          "description": "Model to wire (default: auto — Byte routes to your enabled model)",
           "name": "model",
           "hasDynamicHelp": false,
           "multiple": false,
@@ -612,6 +624,60 @@
         "logout.js"
       ]
     },
+    "metrics": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Request id (from the requests list or the dashboard)",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Full cost / latency / quality breakdown for a single request.",
+      "examples": [
+        "<%= config.bin %> metrics 1429",
+        "<%= config.bin %> requests  # to find an id"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "profile": {
+          "description": "Configuration profile to use",
+          "env": "BYTE_PROFILE",
+          "name": "profile",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "base-url": {
+          "description": "Override the API base URL",
+          "env": "BYTE_BASE_URL",
+          "name": "base-url",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "metrics",
+      "pluginAlias": "@bytevion/cli",
+      "pluginName": "@bytevion/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": false,
+      "relativePath": [
+        "dist",
+        "commands",
+        "metrics.js"
+      ]
+    },
     "run": {
       "aliases": [],
       "args": {
@@ -874,12 +940,18 @@
           "type": "option"
         },
         "model": {
-          "description": "Model id (byte alias) to wire (defaults to the last wired model)",
+          "description": "Model to wire (default: the last wired model, or auto)",
           "name": "model",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
+        "all": {
+          "description": "Re-apply to every wired tool (this is the default)",
+          "name": "all",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "yes": {
           "char": "y",
           "description": "Skip confirmation prompts",
@@ -2200,5 +2272,5 @@
       ]
     }
   },
-  "version": "0.5.0"
+  "version": "0.5.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytevion/cli",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Byte — control your LLM optimization gateway from the terminal.",
   "author": "Byte",
   "license": "UNLICENSED",