@bytevion/cli 0.1.0

package/dist/commands/keys/list.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class KeysList extends base_1.BaseCommand {
+    static description = 'List the Byte API keys for the current org.';
+    async run() {
+        const { flags } = await this.parse(KeysList);
+        this.requireToken(flags);
+        const rows = await this.api(flags).keysList();
+        if (this.jsonEnabled())
+            return rows;
+        if (!rows.length) {
+            this.log('No keys yet. Create one with `byte keys create <name>`.');
+            return rows;
+        }
+        this.log((0, output_1.renderTable)(['ID', 'Name', 'Prefix', 'Preset', 'Active', 'Last used'], rows.map((k) => [k.id, k.name, k.key_prefix, k.preset ?? '-', k.active ? 'yes' : 'no', k.last_used_at ?? '-'])));
+        return rows;
+    }
+}
+exports.default = KeysList;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class KeysRevoke 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/keys/revoke.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 KeysRevoke extends base_1.BaseCommand {
+    static description = 'Revoke (delete) a Byte API key.';
+    static args = {
+        id: core_1.Args.integer({ description: 'Key id (see `byte keys list`)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysRevoke);
+        this.requireToken(flags);
+        const res = await this.api(flags).keysRevoke(args.id);
+        if (!this.jsonEnabled())
+            this.log(`Revoked key ${args.id}.`);
+        return res;
+    }
+}
+exports.default = KeysRevoke;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class KeysRotate 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/keys/rotate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+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 }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KeysRotate);
+        this.requireToken(flags);
+        const res = await this.api(flags).keysRotate(args.id);
+        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`).');
+        }
+        return res;
+    }
+}
+exports.default = KeysRotate;

package/dist/commands/login.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base';
+export default class Login extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'no-browser': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/login.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const node_os_1 = require("node:os");
+const base_1 = require("../base");
+const api_1 = require("../lib/api");
+const config_1 = require("../lib/config");
+const credentials_1 = require("../lib/credentials");
+const errors_1 = require("../lib/errors");
+const util_1 = require("../lib/util");
+class Login extends base_1.BaseCommand {
+    static description = 'Sign in from this terminal by approving a device code in the dashboard.';
+    static examples = ['<%= config.bin %> login', '<%= config.bin %> login --no-browser'];
+    static flags = {
+        'no-browser': core_1.Flags.boolean({ description: 'Do not try to open the browser automatically' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        const profile = this.profileFrom(flags);
+        const base = this.baseUrlFrom(flags);
+        const api = new api_1.ByteApi(base);
+        const start = await api.deviceStart(`byte-cli@${(0, node_os_1.hostname)()}`);
+        const verifyUrl = start.verification_uri_complete || start.verification_uri;
+        this.log('');
+        this.log('  Approve this terminal in your browser:');
+        this.log(`    ${verifyUrl}`);
+        this.log('');
+        this.log(`  Verification code: ${start.user_code}`);
+        this.log('');
+        if (!flags['no-browser']) {
+            try {
+                await (0, util_1.openBrowser)(verifyUrl);
+            }
+            catch {
+                // user can open manually
+            }
+        }
+        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)(profile, tok.access_token);
+                (0, config_1.setProfile)(profile, {
+                    base_url: base,
+                    dashboard_url: (0, config_1.getProfile)(profile).dashboard_url || config_1.DEFAULT_DASHBOARD_URL,
+                    org_id: tok.org?.id,
+                    org_name: tok.org?.name,
+                    email: tok.user?.email,
+                });
+                if (!this.jsonEnabled()) {
+                    this.log(`Signed in as ${tok.user?.email} (org: ${tok.org?.name}).`);
+                    this.log('Next: run `byte init` to add a provider key and create your Byte API key.');
+                }
+                return { status: 'signed_in', email: tok.user?.email, org: tok.org?.name, profile };
+            }
+            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')
+                    return this.error('Authorization was denied in the dashboard.', { exit: 3 });
+                if (code === 'expired_token')
+                    return this.error('The code expired. Run `byte login` again.', { exit: 3 });
+                throw err;
+            }
+        }
+        return this.error('Login timed out. Run `byte login` again.', { exit: 3 });
+    }
+}
+exports.default = Login;

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const credentials_1 = require("../lib/credentials");
+class Logout extends base_1.BaseCommand {
+    static description = 'Sign out of this terminal and revoke the stored session token.';
+    async run() {
+        const { flags } = await this.parse(Logout);
+        const profile = this.profileFrom(flags);
+        if ((0, credentials_1.getToken)(profile)) {
+            try {
+                await this.api(flags).cliLogout();
+            }
+            catch {
+                // revoke is best effort; we always clear locally
+            }
+        }
+        (0, credentials_1.clearCredentials)(profile);
+        if (!this.jsonEnabled())
+            this.log(`Signed out of profile "${profile}".`);
+        return { status: 'signed_out', profile };
+    }
+}
+exports.default = Logout;

package/dist/commands/opt/preset.d.ts

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

package/dist/commands/opt/preset.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class OptPreset extends base_1.BaseCommand {
+    static description = 'Apply an optimization preset for the whole org.';
+    static args = {
+        preset: core_1.Args.string({
+            description: 'Preset to apply',
+            required: true,
+            options: ['balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(OptPreset);
+        this.requireToken(flags);
+        const res = await this.api(flags).optPatch({ default_mode: args.preset });
+        if (!this.jsonEnabled())
+            this.log(`Optimization preset set to "${args.preset}".`);
+        return res;
+    }
+}
+exports.default = OptPreset;

package/dist/commands/opt/set.d.ts

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

package/dist/commands/opt/set.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class OptSet extends base_1.BaseCommand {
+    static description = 'Toggle a single optimization layer on or off. See field names with `byte opt show --json`.';
+    static examples = ['<%= config.bin %> opt set compression_enabled off', '<%= config.bin %> opt set response_cache_enabled on'];
+    static args = {
+        flag: core_1.Args.string({ description: 'Optimization field name', required: true }),
+        value: core_1.Args.string({ description: 'on or off', required: true, options: ['on', 'off', 'true', 'false'] }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(OptSet);
+        this.requireToken(flags);
+        const enabled = args.value === 'on' || args.value === 'true';
+        const res = await this.api(flags).optPatch({ [args.flag]: enabled });
+        if (!this.jsonEnabled())
+            this.log(`Set ${args.flag} = ${enabled}.`);
+        return res;
+    }
+}
+exports.default = OptSet;

package/dist/commands/opt/show.d.ts

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

package/dist/commands/opt/show.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+class OptShow extends base_1.BaseCommand {
+    static description = 'Show the current optimization preset and layer states for the org.';
+    async run() {
+        const { flags } = await this.parse(OptShow);
+        this.requireToken(flags);
+        const res = await this.api(flags).optShow();
+        if (this.jsonEnabled())
+            return res;
+        const settings = res.settings ?? res;
+        this.log(`Preset (default_mode): ${settings.default_mode ?? '-'}`);
+        this.log(`Cache mode:            ${settings.cache_mode ?? '-'}`);
+        const layers = Array.isArray(res.layers) ? res.layers : [];
+        if (layers.length) {
+            const enabled = layers.filter((l) => l.enabled).length;
+            this.log(`Layers enabled:        ${enabled}/${layers.length}`);
+        }
+        this.log('Run with --json for the full settings object.');
+        return res;
+    }
+}
+exports.default = OptShow;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base';
+export default class ProvidersAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'api-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        label: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-fetch': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/providers/add.js

@@ -0,0 +1,40 @@
+"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");
+class ProvidersAdd extends base_1.BaseCommand {
+    static description = 'Add an upstream provider key (BYOK). Byte stores it encrypted and can auto-import models.';
+    static examples = ['<%= config.bin %> providers add', '<%= config.bin %> providers add --api-key sk-... --label "OpenAI prod"'];
+    static flags = {
+        'api-key': core_1.Flags.string({ description: 'Upstream provider API key', env: 'BYTE_PROVIDER_KEY' }),
+        mode: core_1.Flags.string({ description: 'Gateway mode for this provider', default: 'byte_auto' }),
+        label: core_1.Flags.string({ description: 'A label for this connection' }),
+        'no-fetch': core_1.Flags.boolean({ description: 'Skip auto-importing the provider model list' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProvidersAdd);
+        this.requireToken(flags);
+        let apiKey = flags['api-key'];
+        if (!apiKey)
+            apiKey = await (0, util_1.promptHidden)('Upstream provider API key: ');
+        if (!apiKey)
+            return this.error('A provider API key is required.', { exit: 2 });
+        const body = {
+            api_key: apiKey,
+            gateway_mode: flags.mode,
+            auto_fetch: !flags['no-fetch'],
+        };
+        if (flags.label)
+            body.label = flags.label;
+        const res = await this.api(flags).providersAdd(body);
+        if (!this.jsonEnabled()) {
+            const id = res.id ?? res.connection?.id;
+            const imported = res.fetch_result?.imported ?? res.imported ?? 0;
+            this.log(`Provider connection added (id ${id}). Models imported: ${imported}.`);
+            this.log('Next: `byte keys create <name>` then `byte integrate <harness>`.');
+        }
+        return res;
+    }
+}
+exports.default = ProvidersAdd;

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

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

package/dist/commands/providers/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 ProvidersList extends base_1.BaseCommand {
+    static description = 'List upstream provider connections for the current org.';
+    async run() {
+        const { flags } = await this.parse(ProvidersList);
+        this.requireToken(flags);
+        const res = await this.api(flags).providersList();
+        const rows = res.connections ?? res ?? [];
+        if (this.jsonEnabled())
+            return rows;
+        if (!rows.length) {
+            this.log('No provider connections yet. Add one with `byte providers add`.');
+            return rows;
+        }
+        this.log((0, output_1.renderTable)(['ID', 'Label', 'Status', 'Secret', 'Models'], rows.map((c) => [c.id, c.label, c.status ?? '-', c.secret_last4 ? `****${c.secret_last4}` : '-', c.model_count ?? c.models ?? '-'])));
+        return rows;
+    }
+}
+exports.default = ProvidersList;

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base';
+export default class ProvidersRotate extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static flags: {
+        'api-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/providers/rotate.js

@@ -0,0 +1,28 @@
+"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");
+class ProvidersRotate extends base_1.BaseCommand {
+    static description = 'Replace the upstream API key on a provider connection (keeps imported models).';
+    static args = {
+        id: core_1.Args.integer({ description: 'Connection id (see `byte providers list`)', required: true }),
+    };
+    static flags = {
+        'api-key': core_1.Flags.string({ description: 'New upstream provider API key', env: 'BYTE_PROVIDER_KEY' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersRotate);
+        this.requireToken(flags);
+        let apiKey = flags['api-key'];
+        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 });
+        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 ?? '????'}).`);
+        return res;
+    }
+}
+exports.default = ProvidersRotate;

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class ProvidersTest 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/providers/test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class ProvidersTest extends base_1.BaseCommand {
+    static description = 'Verify a provider connection by re-fetching its model list.';
+    static args = {
+        id: core_1.Args.integer({ description: 'Connection id (see `byte providers list`)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ProvidersTest);
+        this.requireToken(flags);
+        const res = await this.api(flags).providersTest(args.id);
+        if (!this.jsonEnabled()) {
+            const imported = res.imported ?? 0;
+            const updated = res.updated ?? 0;
+            this.log(`Connection ${args.id} reachable. Models imported: ${imported}, updated: ${updated}.`);
+        }
+        return res;
+    }
+}
+exports.default = ProvidersTest;

package/dist/commands/run.d.ts

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

package/dist/commands/run.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+class Run extends base_1.BaseCommand {
+    static description = 'Send a one-off prompt through the Byte gateway using your Byte API key.';
+    static examples = ['<%= config.bin %> run "summarize this release note"', '<%= config.bin %> run "hi" --model gpt-4o'];
+    static args = {
+        prompt: core_1.Args.string({ description: 'The prompt to send', required: true }),
+    };
+    static flags = {
+        model: core_1.Flags.string({ description: 'Model or Byte alias', default: 'byte-default' }),
+        'max-tokens': core_1.Flags.integer({ description: 'Maximum output tokens' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Run);
+        const key = this.requireByteKey(flags);
+        const body = { model: flags.model, messages: [{ role: 'user', content: args.prompt }] };
+        if (flags['max-tokens'] !== undefined)
+            body.max_tokens = flags['max-tokens'];
+        const res = await this.api(flags).chat(key, body);
+        if (this.jsonEnabled())
+            return res;
+        const content = res.choices?.[0]?.message?.content ?? '';
+        this.log(content);
+        const u = res.usage ?? {};
+        this.log('');
+        this.log(`— ${u.prompt_tokens ?? 0} in / ${u.completion_tokens ?? 0} out tokens · model ${res.model ?? flags.model}`);
+        return res;
+    }
+}
+exports.default = Run;

package/dist/commands/sessions/index.d.ts

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

package/dist/commands/sessions/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class Sessions extends base_1.BaseCommand {
+    static description = 'List active terminal sessions (CLI tokens) for the org.';
+    async run() {
+        const { flags } = await this.parse(Sessions);
+        this.requireToken(flags);
+        const rows = await this.api(flags).sessions();
+        if (this.jsonEnabled())
+            return rows;
+        if (!rows.length) {
+            this.log('No active CLI sessions.');
+            return rows;
+        }
+        this.log((0, output_1.renderTable)(['ID', 'Name', 'Scope', 'Prefix', 'Last used', 'Expires'], rows.map((s) => [s.id, s.name, s.scope, s.token_prefix, s.last_used_at ?? '-', s.expires_at ?? 'never'])));
+        return rows;
+    }
+}
+exports.default = Sessions;

package/dist/commands/sessions/revoke.d.ts

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

package/dist/commands/sessions/revoke.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 SessionsRevoke extends base_1.BaseCommand {
+    static description = 'Revoke a terminal session (CLI token) by id.';
+    static args = {
+        id: core_1.Args.string({ description: 'Session id (see `byte sessions`)', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SessionsRevoke);
+        this.requireToken(flags);
+        const res = await this.api(flags).revokeSession(args.id);
+        if (!this.jsonEnabled())
+            this.log(`Revoked session ${args.id}.`);
+        return res;
+    }
+}
+exports.default = SessionsRevoke;

package/dist/commands/stats.d.ts

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

package/dist/commands/stats.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const output_1 = require("../lib/output");
+class Stats extends base_1.BaseCommand {
+    static description = 'Headline usage and savings summary for the current org.';
+    async run() {
+        const { flags } = await this.parse(Stats);
+        this.requireToken(flags);
+        const api = this.api(flags);
+        const [summary, cache] = await Promise.all([
+            api.dashboard().catch(() => ({})),
+            api.cacheStats().catch(() => ({})),
+        ]);
+        const out = { summary, cache };
+        if (this.jsonEnabled())
+            return out;
+        const s = summary;
+        const c = cache;
+        this.log(`Requests:       ${s.total_requests ?? s.requests ?? '-'}`);
+        this.log(`Cache hit rate: ${(0, output_1.pct)(s.cache_hit_rate ?? c.hit_rate)}`);
+        this.log(`Total savings:  ${(0, output_1.fmtUsd)(s.savings_usd ?? s.total_savings_usd)}`);
+        this.log(`Cost (Byte):    ${(0, output_1.fmtUsd)(s.cost_byte_usd ?? s.cost_usd)}`);
+        return out;
+    }
+}
+exports.default = Stats;

package/dist/commands/usage.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from '../base';
+export default class Usage extends BaseCommand {
+    static description: string;
+    static flags: {
+        granularity: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}