byterover-cli 1.4.0 → 1.6.0

package/dist/infra/repl/commands/model-command.js

@@ -0,0 +1,212 @@
+/**
+ * Model Command
+ *
+ * Interactive command for selecting LLM models from the active provider.
+ * Uses the streaming command pattern with inline prompts.
+ *
+ * Usage: /model
+ */
+import { getProviderById } from '../../../core/domain/entities/provider-registry.js';
+import { CommandKind } from '../../../tui/types.js';
+import { getOpenRouterApiClient } from '../../http/openrouter-api-client.js';
+import { FileProviderConfigStore } from '../../storage/file-provider-config-store.js';
+import { ProviderKeychainStore } from '../../storage/provider-keychain-store.js';
+/**
+ * Format price for display.
+ * Shows prices in a compact format: <0.01 for tiny prices, otherwise 2 decimal places.
+ */
+function formatPrice(pricePerM) {
+    if (pricePerM === 0)
+        return '0';
+    if (pricePerM < 0.01)
+        return '<0.01';
+    return pricePerM.toFixed(2);
+}
+/**
+ * Build model choices for selection prompt.
+ */
+async function buildModelChoices(providerId, apiKey, config) {
+    const choices = [];
+    if (providerId === 'openrouter') {
+        const client = getOpenRouterApiClient();
+        const models = await client.fetchModels(apiKey);
+        // Sort models: favorites first, then recent, then by provider
+        const sortedModels = [...models].sort((a, b) => {
+            const aIsFavorite = config.favorites.includes(a.id);
+            const bIsFavorite = config.favorites.includes(b.id);
+            const aIsRecent = config.recent.includes(a.id);
+            const bIsRecent = config.recent.includes(b.id);
+            // Favorites first
+            if (aIsFavorite && !bIsFavorite)
+                return -1;
+            if (!aIsFavorite && bIsFavorite)
+                return 1;
+            // Then recent
+            if (aIsRecent && !bIsRecent)
+                return -1;
+            if (!aIsRecent && bIsRecent)
+                return 1;
+            // Then by provider
+            const providerCompare = a.provider.localeCompare(b.provider);
+            if (providerCompare !== 0)
+                return providerCompare;
+            // Then by name
+            return a.name.localeCompare(b.name);
+        });
+        for (const model of sortedModels) {
+            const isCurrent = model.id === config.activeModel;
+            const isFavorite = config.favorites.includes(model.id);
+            // Build indicators
+            const indicators = [];
+            if (isCurrent)
+                indicators.push('(Current)');
+            if (isFavorite && !isCurrent)
+                indicators.push('★');
+            if (model.isFree && !isCurrent)
+                indicators.push('[Free]');
+            const statusSuffix = indicators.length > 0 ? ` ${indicators.join(' ')}` : '';
+            // Build description with pricing and context
+            const descParts = [];
+            if (model.provider)
+                descParts.push(model.provider);
+            if (!model.isFree && model.pricing) {
+                // Show input/output pricing separately for more clarity
+                const inputPrice = formatPrice(model.pricing.inputPerM);
+                const outputPrice = formatPrice(model.pricing.outputPerM);
+                descParts.push(`$${inputPrice}/$${outputPrice}/M`);
+            }
+            if (model.contextLength) {
+                if (model.contextLength >= 1_000_000) {
+                    descParts.push(`${(model.contextLength / 1_000_000).toFixed(1)}M ctx`);
+                }
+                else if (model.contextLength >= 1000) {
+                    descParts.push(`${Math.round(model.contextLength / 1000)}K ctx`);
+                }
+            }
+            choices.push({
+                description: descParts.join(' • '),
+                name: `${model.name}${statusSuffix}`,
+                value: model.id,
+            });
+        }
+    }
+    else if (providerId === 'byterover') {
+        // ByteRover internal - show a single option
+        choices.push({
+            description: 'Internal ByteRover model',
+            name: 'ByteRover Default (Current)',
+            value: 'byterover-default',
+        });
+    }
+    return choices;
+}
+/**
+ * Model command definition.
+ */
+export const modelCommand = {
+    action: () => ({
+        async execute(onMessage, onPrompt) {
+            const configStore = new FileProviderConfigStore();
+            const keychainStore = new ProviderKeychainStore();
+            // Get active provider
+            const config = await configStore.read();
+            const activeProviderId = config.activeProvider;
+            const provider = getProviderById(activeProviderId);
+            if (!provider) {
+                onMessage({
+                    content: `Active provider "${activeProviderId}" not found. Run /provider to select a provider.`,
+                    id: `error-${Date.now()}`,
+                    type: 'error',
+                });
+                return;
+            }
+            // ByteRover doesn't support model selection
+            if (activeProviderId === 'byterover') {
+                onMessage({
+                    content: 'ByteRover uses an internal model. Run /provider to switch to an external provider for model selection.',
+                    id: `info-${Date.now()}`,
+                    type: 'output',
+                });
+                return;
+            }
+            // Get API key for the provider
+            const apiKey = await keychainStore.getApiKey(activeProviderId);
+            if (!apiKey) {
+                onMessage({
+                    content: `No API key found for ${provider.name}. Run /provider to connect.`,
+                    id: `error-${Date.now()}`,
+                    type: 'error',
+                });
+                return;
+            }
+            // Fetch models
+            onMessage({
+                actionId: 'fetch-models',
+                content: `Fetching models from ${provider.name}...`,
+                id: `loading-${Date.now()}`,
+                type: 'action_start',
+            });
+            let choices;
+            try {
+                const activeModel = await configStore.getActiveModel(activeProviderId);
+                const favorites = await configStore.getFavoriteModels(activeProviderId);
+                const recent = await configStore.getRecentModels(activeProviderId);
+                choices = await buildModelChoices(activeProviderId, apiKey, {
+                    activeModel,
+                    favorites,
+                    recent,
+                });
+                onMessage({
+                    actionId: 'fetch-models',
+                    content: `Found ${choices.length} models`,
+                    id: `loaded-${Date.now()}`,
+                    type: 'action_stop',
+                });
+            }
+            catch (error) {
+                onMessage({
+                    actionId: 'fetch-models',
+                    content: 'Failed',
+                    id: `error-${Date.now()}`,
+                    type: 'action_stop',
+                });
+                onMessage({
+                    content: error instanceof Error ? error.message : 'Failed to fetch models',
+                    id: `error-details-${Date.now()}`,
+                    type: 'error',
+                });
+                return;
+            }
+            if (choices.length === 0) {
+                onMessage({
+                    content: 'No models available from this provider.',
+                    id: `empty-${Date.now()}`,
+                    type: 'output',
+                });
+                return;
+            }
+            // Show model selection
+            const selectedModelId = await new Promise((resolve) => {
+                onPrompt({
+                    choices,
+                    message: `Select a model (${provider.name})`,
+                    onResponse: (value) => resolve(value),
+                    type: 'select',
+                });
+            });
+            // Save selected model
+            await configStore.setActiveModel(activeProviderId, selectedModelId);
+            onMessage({
+                content: `Model set to: ${selectedModelId}`,
+                id: `selected-${Date.now()}`,
+                type: 'output',
+            });
+        },
+        type: 'streaming',
+    }),
+    aliases: ['models'],
+    autoExecute: true,
+    description: 'Select a model from the active provider',
+    kind: CommandKind.BUILT_IN,
+    name: 'model',
+};

package/dist/infra/repl/commands/provider-command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Provider Command
+ *
+ * Interactive command for selecting and connecting LLM providers.
+ * Uses the streaming command pattern with inline prompts.
+ *
+ * Usage: /provider
+ */
+import type { SlashCommand } from '../../../tui/types.js';
+/**
+ * Provider command definition.
+ */
+export declare const providerCommand: SlashCommand;

package/dist/infra/repl/commands/provider-command.js

@@ -0,0 +1,181 @@
+/**
+ * Provider Command
+ *
+ * Interactive command for selecting and connecting LLM providers.
+ * Uses the streaming command pattern with inline prompts.
+ *
+ * Usage: /provider
+ */
+import { getProviderById, getProvidersSortedByPriority, providerRequiresApiKey, } from '../../../core/domain/entities/provider-registry.js';
+import { CommandKind } from '../../../tui/types.js';
+import { getOpenRouterApiClient } from '../../http/openrouter-api-client.js';
+import { FileProviderConfigStore } from '../../storage/file-provider-config-store.js';
+import { ProviderKeychainStore } from '../../storage/provider-keychain-store.js';
+/**
+ * Build provider choices for selection prompt.
+ */
+async function buildProviderChoices() {
+    const configStore = new FileProviderConfigStore();
+    const keychainStore = new ProviderKeychainStore();
+    const config = await configStore.read();
+    const providers = getProvidersSortedByPriority();
+    const choices = [];
+    // Check connection status for all providers
+    const connectionStatuses = await Promise.all(providers.map(async (provider) => ({
+        isConnected: provider.id === 'byterover' || (await keychainStore.hasApiKey(provider.id)),
+        provider,
+    })));
+    for (const { isConnected, provider } of connectionStatuses) {
+        const isCurrent = provider.id === config.activeProvider;
+        // Build status indicators
+        const indicators = [];
+        if (isCurrent)
+            indicators.push('(Current)');
+        else if (isConnected)
+            indicators.push('[Connected]');
+        const statusSuffix = indicators.length > 0 ? ` ${indicators.join(' ')}` : '';
+        choices.push({
+            description: provider.description,
+            name: `${provider.name}${statusSuffix}`,
+            value: provider.id,
+        });
+    }
+    return choices;
+}
+/**
+ * Validate API key for a provider.
+ */
+async function validateApiKey(apiKey, providerId) {
+    if (providerId === 'openrouter') {
+        const client = getOpenRouterApiClient();
+        return client.validateApiKey(apiKey);
+    }
+    // For other providers, assume valid
+    return { isValid: true };
+}
+/**
+ * Provider command definition.
+ */
+export const providerCommand = {
+    action: () => ({
+        async execute(onMessage, onPrompt) {
+            const configStore = new FileProviderConfigStore();
+            const keychainStore = new ProviderKeychainStore();
+            // Step 1: Show provider selection
+            const choices = await buildProviderChoices();
+            const selectedProviderId = await new Promise((resolve) => {
+                onPrompt({
+                    choices,
+                    message: 'Select a provider',
+                    onResponse: (value) => resolve(value),
+                    type: 'select',
+                });
+            });
+            const provider = getProviderById(selectedProviderId);
+            if (!provider) {
+                onMessage({
+                    content: `Provider "${selectedProviderId}" not found`,
+                    id: `error-${Date.now()}`,
+                    type: 'error',
+                });
+                return;
+            }
+            // Step 2: Check if already connected
+            const isConnected = provider.id === 'byterover' || (await keychainStore.hasApiKey(provider.id));
+            if (isConnected) {
+                // Already connected - just set as active
+                await configStore.setActiveProvider(provider.id);
+                onMessage({
+                    content: `Switched to ${provider.name}`,
+                    id: `success-${Date.now()}`,
+                    type: 'output',
+                });
+                return;
+            }
+            // Step 3: If provider requires API key, prompt for it
+            if (providerRequiresApiKey(provider.id)) {
+                onMessage({
+                    content: provider.apiKeyUrl
+                        ? `Get your API key at: ${provider.apiKeyUrl}`
+                        : `Enter your ${provider.name} API key`,
+                    id: `info-${Date.now()}`,
+                    type: 'output',
+                });
+                // Prompt for API key with validation
+                let isValid = false;
+                let apiKey = '';
+                while (!isValid) {
+                    // eslint-disable-next-line no-await-in-loop
+                    apiKey = await new Promise((resolve) => {
+                        onPrompt({
+                            message: `Enter ${provider.name} API key`,
+                            onResponse: resolve,
+                            placeholder: 'sk-...',
+                            type: 'input',
+                            validate(value) {
+                                if (!value.trim())
+                                    return 'API key is required';
+                                return true;
+                            },
+                        });
+                    });
+                    // Validate the API key
+                    onMessage({
+                        actionId: 'validate-key',
+                        content: 'Validating API key...',
+                        id: `validating-${Date.now()}`,
+                        type: 'action_start',
+                    });
+                    // eslint-disable-next-line no-await-in-loop
+                    const result = await validateApiKey(apiKey, provider.id);
+                    if (result.isValid) {
+                        isValid = true;
+                        onMessage({
+                            actionId: 'validate-key',
+                            content: 'Valid',
+                            id: `validated-${Date.now()}`,
+                            type: 'action_stop',
+                        });
+                    }
+                    else {
+                        onMessage({
+                            actionId: 'validate-key',
+                            content: 'Invalid',
+                            id: `invalid-${Date.now()}`,
+                            type: 'action_stop',
+                        });
+                        onMessage({
+                            content: result.error ?? 'Invalid API key. Please try again.',
+                            id: `error-${Date.now()}`,
+                            type: 'error',
+                        });
+                    }
+                }
+                // Store API key in keychain
+                await keychainStore.setApiKey(provider.id, apiKey);
+                // Mark provider as connected and set as active
+                await configStore.connectProvider(provider.id);
+                onMessage({
+                    content: `Connected to ${provider.name}`,
+                    id: `connected-${Date.now()}`,
+                    type: 'output',
+                });
+            }
+            else {
+                // Provider doesn't require API key
+                await configStore.connectProvider(provider.id);
+                onMessage({
+                    content: `Switched to ${provider.name}`,
+                    id: `connected-${Date.now()}`,
+                    type: 'output',
+                });
+            }
+        },
+        type: 'streaming',
+    }),
+    aliases: ['providers', 'connect'],
+    autoExecute: true,
+    description: 'Connect to an LLM provider (e.g., OpenRouter)',
+    kind: CommandKind.BUILT_IN,
+    name: 'provider',
+};

package/dist/infra/repl/transport-client-helper.js

@@ -68,6 +68,12 @@ export async function connectTransportClient() {
     try {
         const factory = createTransportClientFactory();
         const { client } = await factory.connect();
+        // IMPORTANT: Join broadcast-room FIRST before subscribing to events.
+        // This prevents missing events that are broadcast during the subscription window.
+        // Pattern inspired by opencode's atomic room join approach.
+        await client.joinRoom('broadcast-room');
+        logEvent('_room', { room: 'broadcast-room', state: 'joined' });
+        // Now subscribe to events - we won't miss any since we're already in the room
         client.onStateChange((state) => {
             logEvent('_connection', { clientId: client.getClientId(), state });
         });
@@ -75,8 +81,6 @@ export async function connectTransportClient() {
             client.on(event, (data) => logEvent(event, data));
         }
         logEvent('_connection', { clientId: client.getClientId(), state: 'initialized' });
-        await client.joinRoom('broadcast-room');
-        logEvent('_room', { room: 'broadcast-room', state: 'joined' });
         return client;
     }
     catch (error) {

package/dist/infra/space/http-space-service.d.ts

@@ -7,7 +7,7 @@ export type SpaceServiceConfig = {
 export declare class HttpSpaceService implements ISpaceService {
     private readonly config;
     constructor(config: SpaceServiceConfig);
-    getSpaces(accessToken: string, sessionKey: string, teamId: string, option?: {
+    getSpaces(sessionKey: string, teamId: string, option?: {
         fetchAll?: boolean;
         limit?: number;
         offset?: number;

package/dist/infra/space/http-space-service.js

@@ -9,9 +9,9 @@ export class HttpSpaceService {
             timeout: 10_000, // Default 10 seconds timeout
         };
     }
-    async getSpaces(accessToken, sessionKey, teamId, option) {
+    async getSpaces(sessionKey, teamId, option) {
         try {
-            const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
+            const httpClient = new AuthenticatedHttpClient(sessionKey);
             // Scenario 1: Fetch all automatically via auto-pagination
             if (option?.fetchAll === true) {
                 return await this.fetchAllSpaces(httpClient, teamId);

package/dist/infra/storage/file-provider-config-store.d.ts

@@ -0,0 +1,83 @@
+/**
+ * File-based Provider Config Store
+ *
+ * Stores provider configuration (non-sensitive data) in a JSON file.
+ * API keys are stored separately in the system keychain.
+ */
+import type { IProviderConfigStore } from '../../core/interfaces/i-provider-config-store.js';
+import { ProviderConfig } from '../../core/domain/entities/provider-config.js';
+/**
+ * Dependencies for FileProviderConfigStore.
+ * Allows injection for testing.
+ */
+export interface FileProviderConfigStoreDeps {
+    readonly getConfigDir: () => string;
+    readonly getConfigPath: () => string;
+}
+/**
+ * File-based implementation of IProviderConfigStore.
+ * Stores configuration in ~/.config/brv/providers.json (or platform equivalent).
+ */
+export declare class FileProviderConfigStore implements IProviderConfigStore {
+    private cachedConfig;
+    private readonly deps;
+    constructor(deps?: FileProviderConfigStoreDeps);
+    /**
+     * Clears the cached config. Useful for testing or forcing a re-read.
+     */
+    clearCache(): void;
+    /**
+     * Marks a provider as connected.
+     */
+    connectProvider(providerId: string, options?: {
+        activeModel?: string;
+    }): Promise<void>;
+    /**
+     * Removes a provider connection.
+     */
+    disconnectProvider(providerId: string): Promise<void>;
+    /**
+     * Gets the active model for a provider.
+     */
+    getActiveModel(providerId: string): Promise<string | undefined>;
+    /**
+     * Gets the active provider ID.
+     */
+    getActiveProvider(): Promise<string>;
+    /**
+     * Gets favorite models for a provider.
+     */
+    getFavoriteModels(providerId: string): Promise<readonly string[]>;
+    /**
+     * Gets recent models for a provider.
+     */
+    getRecentModels(providerId: string): Promise<readonly string[]>;
+    /**
+     * Checks if a provider is connected.
+     */
+    isProviderConnected(providerId: string): Promise<boolean>;
+    /**
+     * Reads the provider configuration from disk.
+     */
+    read(): Promise<ProviderConfig>;
+    /**
+     * Sets the active model for a provider.
+     */
+    setActiveModel(providerId: string, modelId: string): Promise<void>;
+    /**
+     * Sets the active provider.
+     */
+    setActiveProvider(providerId: string): Promise<void>;
+    /**
+     * Toggles a model as favorite.
+     */
+    toggleFavorite(providerId: string, modelId: string): Promise<void>;
+    /**
+     * Writes the provider configuration to disk.
+     */
+    write(config: ProviderConfig): Promise<void>;
+}
+/**
+ * Creates a file-based provider config store instance.
+ */
+export declare function createProviderConfigStore(): IProviderConfigStore;

package/dist/infra/storage/file-provider-config-store.js

@@ -0,0 +1,157 @@
+/**
+ * File-based Provider Config Store
+ *
+ * Stores provider configuration (non-sensitive data) in a JSON file.
+ * API keys are stored separately in the system keychain.
+ */
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ProviderConfig } from '../../core/domain/entities/provider-config.js';
+import { getGlobalConfigDir } from '../../utils/global-config-path.js';
+const PROVIDER_CONFIG_FILE = 'providers.json';
+/**
+ * Default dependencies using the real path functions.
+ */
+const defaultDeps = {
+    getConfigDir: getGlobalConfigDir,
+    getConfigPath: () => join(getGlobalConfigDir(), PROVIDER_CONFIG_FILE),
+};
+/**
+ * File-based implementation of IProviderConfigStore.
+ * Stores configuration in ~/.config/brv/providers.json (or platform equivalent).
+ */
+export class FileProviderConfigStore {
+    cachedConfig;
+    deps;
+    constructor(deps = defaultDeps) {
+        this.deps = deps;
+    }
+    /**
+     * Clears the cached config. Useful for testing or forcing a re-read.
+     */
+    clearCache() {
+        this.cachedConfig = undefined;
+    }
+    /**
+     * Marks a provider as connected.
+     */
+    async connectProvider(providerId, options) {
+        const config = await this.read();
+        const newConfig = config
+            .withProviderConnected(providerId, options)
+            .withActiveProvider(providerId);
+        await this.write(newConfig);
+    }
+    /**
+     * Removes a provider connection.
+     */
+    async disconnectProvider(providerId) {
+        const config = await this.read();
+        const newConfig = config.withProviderDisconnected(providerId);
+        await this.write(newConfig);
+    }
+    /**
+     * Gets the active model for a provider.
+     */
+    async getActiveModel(providerId) {
+        const config = await this.read();
+        return config.getActiveModel(providerId);
+    }
+    /**
+     * Gets the active provider ID.
+     */
+    async getActiveProvider() {
+        const config = await this.read();
+        return config.activeProvider;
+    }
+    /**
+     * Gets favorite models for a provider.
+     */
+    async getFavoriteModels(providerId) {
+        const config = await this.read();
+        return config.getFavoriteModels(providerId);
+    }
+    /**
+     * Gets recent models for a provider.
+     */
+    async getRecentModels(providerId) {
+        const config = await this.read();
+        return config.getRecentModels(providerId);
+    }
+    /**
+     * Checks if a provider is connected.
+     */
+    async isProviderConnected(providerId) {
+        const config = await this.read();
+        return config.isProviderConnected(providerId);
+    }
+    /**
+     * Reads the provider configuration from disk.
+     */
+    async read() {
+        if (this.cachedConfig) {
+            return this.cachedConfig;
+        }
+        const configPath = this.deps.getConfigPath();
+        if (!existsSync(configPath)) {
+            this.cachedConfig = ProviderConfig.createDefault();
+            return this.cachedConfig;
+        }
+        try {
+            const content = await readFile(configPath, 'utf8');
+            const json = JSON.parse(content);
+            this.cachedConfig = ProviderConfig.fromJson(json);
+            return this.cachedConfig;
+        }
+        catch {
+            // Return default config for any error
+            this.cachedConfig = ProviderConfig.createDefault();
+            return this.cachedConfig;
+        }
+    }
+    /**
+     * Sets the active model for a provider.
+     */
+    async setActiveModel(providerId, modelId) {
+        const config = await this.read();
+        const newConfig = config.withActiveModel(providerId, modelId);
+        await this.write(newConfig);
+    }
+    /**
+     * Sets the active provider.
+     */
+    async setActiveProvider(providerId) {
+        const config = await this.read();
+        const newConfig = config.withActiveProvider(providerId);
+        await this.write(newConfig);
+    }
+    /**
+     * Toggles a model as favorite.
+     */
+    async toggleFavorite(providerId, modelId) {
+        const config = await this.read();
+        const newConfig = config.withFavoriteToggled(providerId, modelId);
+        await this.write(newConfig);
+    }
+    /**
+     * Writes the provider configuration to disk.
+     */
+    async write(config) {
+        const configDir = this.deps.getConfigDir();
+        const configPath = this.deps.getConfigPath();
+        // Create config directory if it doesn't exist
+        await mkdir(configDir, { recursive: true });
+        // Write config file
+        const content = JSON.stringify(config.toJson(), null, 2);
+        await writeFile(configPath, content, 'utf8');
+        // Update cache
+        this.cachedConfig = config;
+    }
+}
+/**
+ * Creates a file-based provider config store instance.
+ */
+export function createProviderConfigStore() {
+    return new FileProviderConfigStore();
+}