@bytevion/cli 0.1.0

package/dist/commands/usage.js

@@ -0,0 +1,32 @@
+"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");
+class Usage extends base_1.BaseCommand {
+    static description = 'Show usage and savings over time for the current org.';
+    static flags = {
+        granularity: core_1.Flags.string({ description: 'Bucket size', options: ['day', 'hour'], default: 'day' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Usage);
+        this.requireToken(flags);
+        const res = await this.api(flags).usage(flags.granularity);
+        if (this.jsonEnabled())
+            return res;
+        const points = res.series ?? res.points ?? (Array.isArray(res) ? res : []);
+        if (!points.length) {
+            this.log('No usage recorded yet.');
+            return res;
+        }
+        this.log((0, output_1.renderTable)(['Bucket', 'Requests', 'Tokens', 'Cost', 'Savings'], points.map((p) => [
+            p.bucket ?? p.date ?? p.t ?? '-',
+            p.requests ?? p.total_requests ?? '-',
+            p.tokens ?? p.total_tokens ?? '-',
+            (0, output_1.fmtUsd)(p.cost_usd ?? p.cost_byte_usd),
+            (0, output_1.fmtUsd)(p.savings_usd),
+        ])));
+        return res;
+    }
+}
+exports.default = Usage;

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+class Whoami extends base_1.BaseCommand {
+    static description = 'Show the signed-in identity for the current profile.';
+    async run() {
+        const { flags } = await this.parse(Whoami);
+        this.requireToken(flags);
+        const me = await this.api(flags).me();
+        if (!this.jsonEnabled()) {
+            this.log(`Email:   ${me.user?.email ?? '-'}`);
+            this.log(`Org:     ${me.org?.name ?? '-'} (id ${me.org?.id ?? '-'})`);
+            this.log(`Profile: ${this.profileFrom(flags)}`);
+            this.log(`API:     ${this.baseUrlFrom(flags)}`);
+        }
+        return me;
+    }
+}
+exports.default = Whoami;

package/dist/lib/api.d.ts

@@ -0,0 +1,40 @@
+interface RequestOptions {
+    body?: unknown;
+    auth?: string;
+}
+export declare class ByteApi {
+    private readonly baseUrl;
+    private readonly token?;
+    constructor(baseUrl: string, token?: string);
+    request<T = any>(method: string, path: string, opts?: RequestOptions): Promise<T>;
+    deviceStart(clientName: string): Promise<any>;
+    deviceToken(deviceCode: string): Promise<any>;
+    me(): Promise<any>;
+    cliLogout(): Promise<any>;
+    sessions(): Promise<any>;
+    revokeSession(id: string): Promise<any>;
+    createCiToken(name: string): Promise<any>;
+    keysList(): Promise<any>;
+    keysCreate(body: Record<string, unknown>): Promise<any>;
+    keysRevoke(id: number): Promise<any>;
+    keysRotate(id: number): Promise<any>;
+    providersList(): Promise<any>;
+    providersAdd(body: Record<string, unknown>): Promise<any>;
+    providersRotate(id: number, apiKey: string): Promise<any>;
+    providersTest(id: number): Promise<any>;
+    optShow(): Promise<any>;
+    optPatch(body: Record<string, unknown>): Promise<any>;
+    usage(granularity: string): Promise<any>;
+    dashboard(): Promise<any>;
+    cacheStats(): Promise<any>;
+    costs(): Promise<any>;
+    health(): Promise<any>;
+    batchList(): Promise<any>;
+    batchSubmit(body: Record<string, unknown>): Promise<any>;
+    batchGet(id: string): Promise<any>;
+    batchRun(id: string): Promise<any>;
+    chat(byteKey: string, body: Record<string, unknown>): Promise<any>;
+    models(byteKey: string): Promise<any>;
+    probeMessages(byteKey: string): Promise<any>;
+}
+export {};

package/dist/lib/api.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteApi = void 0;
+const errors_1 = require("./errors");
+class ByteApi {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.token = token;
+    }
+    async request(method, path, opts = {}) {
+        const headers = { Accept: 'application/json' };
+        const auth = opts.auth ?? this.token;
+        if (auth)
+            headers.Authorization = `Bearer ${auth}`;
+        if (opts.body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers,
+                body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'network error';
+            throw new errors_1.ByteError(`Cannot reach ${this.baseUrl} (${message})`, 'BYTE_API_OFFLINE', 5, 0);
+        }
+        const text = await res.text();
+        let data;
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = text;
+            }
+        }
+        if (!res.ok) {
+            const detail = (data && typeof data === 'object' && (data.detail ?? data.error)) || res.statusText;
+            const code = typeof detail === 'string' ? detail : 'BYTE_HTTP_ERROR';
+            const message = typeof detail === 'string' ? detail : JSON.stringify(detail);
+            throw new errors_1.ByteError(message, code, (0, errors_1.exitForStatus)(res.status), res.status);
+        }
+        return data;
+    }
+    // --- device auth ---
+    deviceStart(clientName) {
+        return this.request('POST', '/api/v1/auth/device/start', { body: { client_name: clientName } });
+    }
+    deviceToken(deviceCode) {
+        return this.request('POST', '/api/v1/auth/device/token', { body: { device_code: deviceCode } });
+    }
+    me() {
+        return this.request('GET', '/api/v1/auth/me');
+    }
+    cliLogout() {
+        return this.request('POST', '/api/v1/auth/cli/logout', { body: {} });
+    }
+    sessions() {
+        return this.request('GET', '/api/v1/cli/sessions');
+    }
+    revokeSession(id) {
+        return this.request('DELETE', `/api/v1/cli/sessions/${encodeURIComponent(id)}`);
+    }
+    createCiToken(name) {
+        return this.request('POST', '/api/v1/cli/tokens', { body: { name, scope: 'ci' } });
+    }
+    // --- Byte keys ---
+    keysList() {
+        return this.request('GET', '/api/v1/keys');
+    }
+    keysCreate(body) {
+        return this.request('POST', '/api/v1/keys', { body });
+    }
+    keysRevoke(id) {
+        return this.request('DELETE', `/api/v1/keys/${id}`);
+    }
+    keysRotate(id) {
+        return this.request('POST', `/api/v1/keys/${id}/rotate`, { body: {} });
+    }
+    // --- providers (BYOK) ---
+    providersList() {
+        return this.request('GET', '/api/v1/model-connections');
+    }
+    providersAdd(body) {
+        return this.request('POST', '/api/v1/model-connections', { body });
+    }
+    providersRotate(id, apiKey) {
+        return this.request('PATCH', `/api/v1/model-connections/${id}`, { body: { api_key: apiKey } });
+    }
+    providersTest(id) {
+        return this.request('POST', `/api/v1/model-connections/${id}/fetch-models`, { body: {} });
+    }
+    // --- optimizations ---
+    optShow() {
+        return this.request('GET', '/api/v1/optimizations');
+    }
+    optPatch(body) {
+        return this.request('PATCH', '/api/v1/optimizations', { body });
+    }
+    // --- observability ---
+    usage(granularity) {
+        return this.request('GET', `/api/v1/usage/timeseries?granularity=${encodeURIComponent(granularity)}`);
+    }
+    dashboard() {
+        return this.request('GET', '/api/v1/dashboard/summary');
+    }
+    cacheStats() {
+        return this.request('GET', '/api/v1/cache/stats');
+    }
+    costs() {
+        return this.request('GET', '/api/v1/costs/breakdown');
+    }
+    health() {
+        return this.request('GET', '/api/v1/health');
+    }
+    // --- batch jobs ---
+    batchList() {
+        return this.request('GET', '/api/v1/batch/jobs');
+    }
+    batchSubmit(body) {
+        return this.request('POST', '/api/v1/batch/jobs', { body });
+    }
+    batchGet(id) {
+        return this.request('GET', `/api/v1/batch/jobs/${encodeURIComponent(id)}`);
+    }
+    batchRun(id) {
+        return this.request('POST', `/api/v1/batch/jobs/${encodeURIComponent(id)}/run`, { body: {} });
+    }
+    // --- gateway (authenticated with a byte_sk_live_ key, not the control token) ---
+    chat(byteKey, body) {
+        return this.request('POST', '/v1/chat/completions', { body, auth: byteKey });
+    }
+    models(byteKey) {
+        return this.request('GET', '/v1/models', { auth: byteKey });
+    }
+    probeMessages(byteKey) {
+        return this.request('POST', '/v1/messages', {
+            auth: byteKey,
+            body: { model: 'byte-default', max_tokens: 1, messages: [{ role: 'user', content: 'ping' }] },
+        });
+    }
+}
+exports.ByteApi = ByteApi;

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_BASE_URL = "https://admin.bytevion.com";
+export declare const DEFAULT_DASHBOARD_URL = "https://admin.bytevion.com";
+export interface Profile {
+    base_url: string;
+    dashboard_url: string;
+    org_id?: number;
+    org_name?: string;
+    email?: string;
+    byte_key_prefix?: string;
+}
+export interface ByteConfig {
+    version: number;
+    current_profile: string;
+    profiles: Record<string, Profile>;
+}
+export declare function loadConfig(): ByteConfig;
+export declare function saveConfig(cfg: ByteConfig): void;
+export declare function profileName(override?: string): string;
+export declare function getProfile(name?: string): Profile;
+export declare function setProfile(name: string, patch: Partial<Profile>): void;

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DASHBOARD_URL = exports.DEFAULT_BASE_URL = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.profileName = profileName;
+exports.getProfile = getProfile;
+exports.setProfile = setProfile;
+const node_fs_1 = require("node:fs");
+const paths_1 = require("./paths");
+// Production serves the dashboard, control plane (/api/v1) and gateway (/v1)
+// from a single host. api.bytevion.com is not provisioned, so default to the
+// live host; override per-profile with --base-url or BYTE_BASE_URL.
+exports.DEFAULT_BASE_URL = 'https://admin.bytevion.com';
+exports.DEFAULT_DASHBOARD_URL = 'https://admin.bytevion.com';
+function blankProfile() {
+    return { base_url: exports.DEFAULT_BASE_URL, dashboard_url: exports.DEFAULT_DASHBOARD_URL };
+}
+function blankConfig() {
+    return { version: 1, current_profile: 'default', profiles: { default: blankProfile() } };
+}
+function loadConfig() {
+    try {
+        const data = JSON.parse((0, node_fs_1.readFileSync)((0, paths_1.configPath)(), 'utf8'));
+        if (!data || typeof data !== 'object' || !data.profiles)
+            return blankConfig();
+        return data;
+    }
+    catch {
+        return blankConfig();
+    }
+}
+function saveConfig(cfg) {
+    const path = (0, paths_1.configPath)();
+    const tmp = `${path}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+    (0, node_fs_1.renameSync)(tmp, path);
+}
+function profileName(override) {
+    return override || process.env.BYTE_PROFILE || loadConfig().current_profile || 'default';
+}
+function getProfile(name) {
+    const cfg = loadConfig();
+    const key = name || cfg.current_profile || 'default';
+    return cfg.profiles[key] || blankProfile();
+}
+function setProfile(name, patch) {
+    const cfg = loadConfig();
+    cfg.profiles[name] = { ...(cfg.profiles[name] || blankProfile()), ...patch };
+    cfg.current_profile = name;
+    saveConfig(cfg);
+}

package/dist/lib/credentials.d.ts

@@ -0,0 +1,5 @@
+export declare function getToken(profile: string): string | undefined;
+export declare function setToken(profile: string, token: string): void;
+export declare function getByteKey(profile: string): string | undefined;
+export declare function setByteKey(profile: string, key: string): void;
+export declare function clearCredentials(profile: string): void;

package/dist/lib/credentials.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToken = getToken;
+exports.setToken = setToken;
+exports.getByteKey = getByteKey;
+exports.setByteKey = setByteKey;
+exports.clearCredentials = clearCredentials;
+const node_fs_1 = require("node:fs");
+const paths_1 = require("./paths");
+function load() {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)((0, paths_1.credentialsPath)(), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function persist(store) {
+    const path = (0, paths_1.credentialsPath)();
+    const tmp = `${path}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(store), { mode: 0o600 });
+    (0, node_fs_1.renameSync)(tmp, path);
+    try {
+        (0, node_fs_1.chmodSync)(path, 0o600);
+    }
+    catch {
+        // best effort on platforms without POSIX modes
+    }
+}
+function getToken(profile) {
+    return process.env.BYTE_TOKEN || load()[profile]?.token;
+}
+function setToken(profile, token) {
+    const store = load();
+    store[profile] = { ...(store[profile] || {}), token };
+    persist(store);
+}
+function getByteKey(profile) {
+    return process.env.BYTE_API_KEY || load()[profile]?.byte_key;
+}
+function setByteKey(profile, key) {
+    const store = load();
+    store[profile] = { ...(store[profile] || {}), byte_key: key };
+    persist(store);
+}
+function clearCredentials(profile) {
+    const store = load();
+    delete store[profile];
+    persist(store);
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class ByteError extends Error {
+    readonly code: string;
+    readonly exit: number;
+    readonly status?: number;
+    constructor(message: string, code?: string, exit?: number, status?: number);
+}
+export declare function exitForStatus(status: number): number;

package/dist/lib/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteError = void 0;
+exports.exitForStatus = exitForStatus;
+// Exit codes (mirrors the dashboard error vocabulary):
+//   0 ok, 2 usage (oclif default), 3 auth, 4 not-configured, 5 offline, 6 upstream
+class ByteError extends Error {
+    code;
+    exit;
+    status;
+    constructor(message, code = 'BYTE_ERROR', exit = 1, status) {
+        super(message);
+        this.name = 'ByteError';
+        this.code = code;
+        this.exit = exit;
+        this.status = status;
+    }
+}
+exports.ByteError = ByteError;
+function exitForStatus(status) {
+    if (status === 0)
+        return 5;
+    if (status === 401 || status === 403)
+        return 3;
+    if (status === 404 || status === 503)
+        return 4;
+    if (status >= 500)
+        return 6;
+    return 1;
+}

package/dist/lib/integrations.d.ts

@@ -0,0 +1,23 @@
+export type Compat = 'openai' | 'anthropic';
+export interface IntegrationContext {
+    baseUrl: string;
+    byteKey: string;
+}
+export interface SettingsFile {
+    path: string;
+    apply: (existing: any) => any;
+}
+export interface IntegrationResult {
+    env: Array<[string, string]>;
+    instructions: string[];
+    settingsFile?: SettingsFile;
+}
+export interface Integration {
+    key: string;
+    aliases: string[];
+    title: string;
+    compat: Compat;
+    build: (ctx: IntegrationContext) => IntegrationResult;
+}
+export declare function listIntegrations(): Integration[];
+export declare function findIntegration(name: string): Integration | undefined;

package/dist/lib/integrations.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listIntegrations = listIntegrations;
+exports.findIntegration = findIntegration;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const INTEGRATIONS = [
+    {
+        key: 'claude-code',
+        aliases: ['claudecode', 'claude'],
+        title: 'Claude Code',
+        compat: 'anthropic',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [
+                ['ANTHROPIC_BASE_URL', baseUrl],
+                ['ANTHROPIC_AUTH_TOKEN', byteKey],
+            ],
+            instructions: [
+                'Claude Code reads ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN from its environment',
+                'or from ~/.claude/settings.json. Set the env vars below, or use --write to update',
+                'the settings file. Then start Claude Code as usual.',
+            ],
+            settingsFile: {
+                path: (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'settings.json'),
+                apply: (existing) => ({
+                    ...(existing && typeof existing === 'object' ? existing : {}),
+                    env: {
+                        ...(existing?.env && typeof existing.env === 'object' ? existing.env : {}),
+                        ANTHROPIC_BASE_URL: baseUrl,
+                        ANTHROPIC_AUTH_TOKEN: byteKey,
+                    },
+                }),
+            },
+        }),
+    },
+    {
+        key: 'codex',
+        aliases: ['codex-cli', 'openai-codex'],
+        title: 'Codex CLI',
+        compat: 'openai',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [
+                ['OPENAI_BASE_URL', `${baseUrl}/v1`],
+                ['OPENAI_API_KEY', byteKey],
+            ],
+            instructions: [
+                'Codex CLI uses OPENAI_BASE_URL + OPENAI_API_KEY. Set the env vars below',
+                '(or add a matching model_provider base_url in ~/.codex/config.toml), then run codex.',
+            ],
+        }),
+    },
+    {
+        key: 'cursor',
+        aliases: [],
+        title: 'Cursor',
+        compat: 'openai',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [],
+            instructions: [
+                'In Cursor: Settings -> Models -> enable "Override OpenAI Base URL", then set',
+                `  Base URL: ${baseUrl}/v1`,
+                `  API Key:  ${byteKey}`,
+                'Pick a model from the list (populated from Byte once a provider is connected).',
+            ],
+        }),
+    },
+    {
+        key: 'cline',
+        aliases: [],
+        title: 'Cline (VS Code)',
+        compat: 'openai',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [],
+            instructions: [
+                'In Cline: set API Provider = "OpenAI Compatible", then',
+                `  Base URL: ${baseUrl}/v1`,
+                `  API Key:  ${byteKey}`,
+                '  Model:    an enabled alias (see `byte providers test <id>`).',
+            ],
+        }),
+    },
+    {
+        key: 'aider',
+        aliases: [],
+        title: 'Aider',
+        compat: 'openai',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [
+                ['OPENAI_API_BASE', `${baseUrl}/v1`],
+                ['OPENAI_API_KEY', byteKey],
+            ],
+            instructions: [
+                'Aider honors OPENAI_API_BASE + OPENAI_API_KEY (or ~/.aider.conf.yml: openai-api-base).',
+                'Set the env vars below, then run e.g. `aider --model openai/<alias>`.',
+            ],
+        }),
+    },
+    {
+        key: 'openai',
+        aliases: ['openai-sdk'],
+        title: 'OpenAI SDK',
+        compat: 'openai',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [
+                ['OPENAI_BASE_URL', `${baseUrl}/v1`],
+                ['OPENAI_API_KEY', byteKey],
+            ],
+            instructions: [
+                'Python:',
+                `  from openai import OpenAI`,
+                `  client = OpenAI(base_url="${baseUrl}/v1", api_key="${byteKey}")`,
+                'JavaScript:',
+                `  import OpenAI from "openai"`,
+                `  const client = new OpenAI({ baseURL: "${baseUrl}/v1", apiKey: "${byteKey}" })`,
+            ],
+        }),
+    },
+    {
+        key: 'anthropic',
+        aliases: ['anthropic-sdk'],
+        title: 'Anthropic SDK',
+        compat: 'anthropic',
+        build: ({ baseUrl, byteKey }) => ({
+            env: [
+                ['ANTHROPIC_BASE_URL', baseUrl],
+                ['ANTHROPIC_AUTH_TOKEN', byteKey],
+            ],
+            instructions: [
+                'Python:',
+                `  from anthropic import Anthropic`,
+                `  client = Anthropic(base_url="${baseUrl}", auth_token="${byteKey}")`,
+                'JavaScript:',
+                `  import Anthropic from "@anthropic-ai/sdk"`,
+                `  const client = new Anthropic({ baseURL: "${baseUrl}", authToken: "${byteKey}" })`,
+            ],
+        }),
+    },
+];
+function listIntegrations() {
+    return INTEGRATIONS;
+}
+function findIntegration(name) {
+    const needle = name.toLowerCase();
+    return INTEGRATIONS.find((i) => i.key === needle || i.aliases.includes(needle));
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,4 @@
+export declare function renderTable(head: string[], rows: Array<Array<string | number | null | undefined>>): string;
+export declare function maskKey(value: string | undefined): string;
+export declare function fmtUsd(value: unknown): string;
+export declare function pct(value: unknown): string;

package/dist/lib/output.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+exports.maskKey = maskKey;
+exports.fmtUsd = fmtUsd;
+exports.pct = pct;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+function renderTable(head, rows) {
+    const table = new cli_table3_1.default({ head });
+    for (const row of rows) {
+        table.push(row.map((cell) => (cell === null || cell === undefined ? '' : String(cell))));
+    }
+    return table.toString();
+}
+function maskKey(value) {
+    if (!value)
+        return '';
+    if (value.length <= 12)
+        return value;
+    return `${value.slice(0, 16)}...${value.slice(-4)}`;
+}
+function fmtUsd(value) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return '-';
+    return `$${n.toFixed(n >= 1 ? 2 : 4)}`;
+}
+function pct(value) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return '-';
+    const scaled = n <= 1 ? n * 100 : n;
+    return `${scaled.toFixed(1)}%`;
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function byteDir(): string;
+export declare function configPath(): string;
+export declare function credentialsPath(): string;

package/dist/lib/paths.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byteDir = byteDir;
+exports.configPath = configPath;
+exports.credentialsPath = credentialsPath;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function byteDir() {
+    const dir = process.env.BYTE_HOME || (0, node_path_1.join)((0, node_os_1.homedir)(), '.byte');
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+function configPath() {
+    return (0, node_path_1.join)(byteDir(), 'config.json');
+}
+function credentialsPath() {
+    return (0, node_path_1.join)(byteDir(), 'credentials.json');
+}

package/dist/lib/shell.d.ts

@@ -0,0 +1,4 @@
+export type Shell = 'bash' | 'zsh' | 'fish' | 'powershell' | 'cmd';
+export declare function detectShell(override?: string): Shell;
+export declare function formatEnv(shell: Shell, key: string, value: string): string;
+export declare function formatEnvBlock(shell: Shell, vars: Array<[string, string]>): string;