byterover-cli 1.7.2 → 2.0.0

package/dist/oclif/commands/hub/registry/add.js

@@ -0,0 +1,74 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { HubEvents, } from '../../../../shared/transport/events/hub-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../../lib/json-response.js';
+export default class HubRegistryAdd extends Command {
+    static args = {
+        name: Args.string({
+            description: 'Registry name',
+            required: true,
+        }),
+    };
+    static description = 'Add a hub registry';
+    static examples = [
+        '<%= config.bin %> hub registry add myco --url https://example.com/registry.json',
+        '<%= config.bin %> hub registry add myco --url https://example.com/registry.json --token secret',
+        '<%= config.bin %> hub registry add ghrepo --url https://raw.githubusercontent.com/org/repo/main/registry.json --auth-scheme token --token ghp_xxx',
+        '<%= config.bin %> hub registry add gitlab --url https://gitlab.com/.../registry.json --auth-scheme custom-header --header-name PRIVATE-TOKEN --token glpat-xxx',
+    ];
+    static flags = {
+        'auth-scheme': Flags.string({
+            char: 's',
+            description: 'Auth scheme for hub registry',
+            options: ['bearer', 'token', 'basic', 'custom-header', 'none'],
+        }),
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+        'header-name': Flags.string({
+            description: 'Custom header name (for custom-header auth scheme)',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'Auth token for private hub registry',
+        }),
+        url: Flags.string({
+            char: 'u',
+            description: 'Registry URL',
+            required: true,
+        }),
+    };
+    async executeAdd(params, options) {
+        return withDaemonRetry(async (client) => client.requestWithAck(HubEvents.REGISTRY_ADD, params), options);
+    }
+    async run() {
+        const { args, flags } = await this.parse(HubRegistryAdd);
+        const format = flags.format;
+        try {
+            const result = await this.executeAdd({
+                authScheme: flags['auth-scheme'],
+                headerName: flags['header-name'],
+                name: args.name,
+                token: flags.token,
+                url: flags.url,
+            });
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry add', data: result, success: result.success });
+            }
+            else {
+                this.log(result.message);
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry add', data: { error: formatConnectionError(error) }, success: false });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+}

package/dist/oclif/commands/hub/registry/index.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class HubRegistry extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/oclif/commands/hub/registry/index.js

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class HubRegistry extends Command {
+    static description = 'Manage hub registries';
+    async run() {
+        await this.config.runCommand('hub:registry:list', this.argv);
+    }
+}

package/dist/oclif/commands/hub/registry/list.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import { type HubRegistryListResponse } from '../../../../shared/transport/events/hub-events.js';
+import { type DaemonClientOptions } from '../../../lib/daemon-client.js';
+export default class HubRegistryList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected fetchRegistries(options?: DaemonClientOptions): Promise<HubRegistryListResponse>;
+    run(): Promise<void>;
+}

package/dist/oclif/commands/hub/registry/list.js

@@ -0,0 +1,49 @@
+import { Command, Flags } from '@oclif/core';
+import { HubEvents } from '../../../../shared/transport/events/hub-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../../lib/json-response.js';
+export default class HubRegistryList extends Command {
+    static description = 'List configured hub registries';
+    static examples = [
+        '<%= config.bin %> hub registry list',
+        '<%= config.bin %> hub registry list --format json',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+    };
+    async fetchRegistries(options) {
+        return withDaemonRetry(async (client) => client.requestWithAck(HubEvents.REGISTRY_LIST), options);
+    }
+    async run() {
+        const { flags } = await this.parse(HubRegistryList);
+        const format = flags.format;
+        try {
+            const data = await this.fetchRegistries();
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry list', data, success: true });
+            }
+            else {
+                this.log(`Registries (${data.registries.length}):\n`);
+                for (const r of data.registries) {
+                    const scheme = r.authScheme && r.authScheme !== 'none' && r.authScheme !== 'bearer' ? ` [${r.authScheme}]` : '';
+                    const tokenLabel = r.hasToken ? ' (authenticated)' : '';
+                    const statusLabel = r.status === 'ok' ? `${r.entryCount} entries` : `error: ${r.error}`;
+                    this.log(`  ${r.name} - ${r.url}${scheme}${tokenLabel} (${statusLabel})`);
+                }
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry list', data: { error: formatConnectionError(error) }, success: false });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+}

package/dist/oclif/commands/hub/registry/remove.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { type HubRegistryRemoveRequest, type HubRegistryRemoveResponse } from '../../../../shared/transport/events/hub-events.js';
+import { type DaemonClientOptions } from '../../../lib/daemon-client.js';
+export default class HubRegistryRemove extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected executeRemove(params: HubRegistryRemoveRequest, options?: DaemonClientOptions): Promise<HubRegistryRemoveResponse>;
+    run(): Promise<void>;
+}

package/dist/oclif/commands/hub/registry/remove.js

@@ -0,0 +1,46 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { HubEvents, } from '../../../../shared/transport/events/hub-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../../lib/json-response.js';
+export default class HubRegistryRemove extends Command {
+    static args = {
+        name: Args.string({
+            description: 'Registry name to remove',
+            required: true,
+        }),
+    };
+    static description = 'Remove a hub registry';
+    static examples = ['<%= config.bin %> hub registry remove myco'];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+    };
+    async executeRemove(params, options) {
+        return withDaemonRetry(async (client) => client.requestWithAck(HubEvents.REGISTRY_REMOVE, params), options);
+    }
+    async run() {
+        const { args, flags } = await this.parse(HubRegistryRemove);
+        const format = flags.format;
+        try {
+            const result = await this.executeRemove({ name: args.name });
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry remove', data: result, success: result.success });
+            }
+            else {
+                this.log(result.message);
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({ command: 'hub registry remove', data: { error: formatConnectionError(error) }, success: false });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+}

package/dist/oclif/commands/login.d.ts

@@ -1,9 +1,13 @@
 import { Command } from '@oclif/core';
+import { type AuthLoginWithApiKeyResponse } from '../../shared/transport/events/auth-events.js';
+import { type DaemonClientOptions } from '../lib/daemon-client.js';
 export default class Login extends Command {
     static description: string;
     static examples: string[];
     static flags: {
         'api-key': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
+    protected loginWithApiKey(apiKey: string, options?: DaemonClientOptions): Promise<AuthLoginWithApiKeyResponse>;
     run(): Promise<void>;
 }

package/dist/oclif/commands/login.js

@@ -1,45 +1,65 @@
 import { Command, Flags } from '@oclif/core';
-import { getAuthConfig } from '../../server/config/auth.config.js';
-import { getCurrentConfig } from '../../server/config/environment.js';
-import { OAuthService } from '../../server/infra/auth/oauth-service.js';
-import { OidcDiscoveryService } from '../../server/infra/auth/oidc-discovery-service.js';
-import { SystemBrowserLauncher } from '../../server/infra/browser/system-browser-launcher.js';
-import { CallbackHandler } from '../../server/infra/http/callback-handler.js';
-import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
-import { createTokenStore } from '../../server/infra/storage/token-store.js';
-import { OclifTerminal } from '../../server/infra/terminal/oclif-terminal.js';
-import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
-import { LoginUseCase } from '../../server/infra/usecase/login-use-case.js';
-import { HttpUserService } from '../../server/infra/user/http-user-service.js';
+import { AuthEvents } from '../../shared/transport/events/auth-events.js';
+import { formatConnectionError, withDaemonRetry } from '../lib/daemon-client.js';
+import { writeJsonResponse } from '../lib/json-response.js';
 export default class Login extends Command {
-    static description = 'Authenticate with ByteRover using an API key';
-    static examples = ['<%= config.bin %> <%= command.id %> --api-key <key>'];
+    static description = 'Authenticate with ByteRover for cloud sync features (optional for local usage)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --api-key <key>',
+        '',
+        '# JSON output (for automation)',
+        '<%= config.bin %> <%= command.id %> --api-key <key> --format json',
+    ];
     static flags = {
         'api-key': Flags.string({
             char: 'k',
             description: 'API key for authentication (get yours at https://app.byterover.dev/settings/keys)',
             required: true,
         }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
     };
+    async loginWithApiKey(apiKey, options) {
+        return withDaemonRetry(async (client) => client.requestWithAck(AuthEvents.LOGIN_WITH_API_KEY, { apiKey }), options);
+    }
     async run() {
         const { flags } = await this.parse(Login);
         const apiKey = flags['api-key'];
-        const config = getCurrentConfig();
-        const tokenStore = createTokenStore();
-        const globalConfigStore = new FileGlobalConfigStore();
-        const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
-        const terminal = new OclifTerminal(this);
-        const discoveryService = new OidcDiscoveryService();
-        const authConfig = await getAuthConfig(discoveryService);
-        const useCase = new LoginUseCase({
-            authService: new OAuthService(authConfig),
-            browserLauncher: new SystemBrowserLauncher(),
-            callbackHandler: new CallbackHandler(),
-            terminal,
-            tokenStore,
-            trackingService,
-            userService: new HttpUserService({ apiBaseUrl: config.apiBaseUrl }),
-        });
-        await useCase.run({ apiKey });
+        const format = (flags.format ?? 'text');
+        try {
+            if (format === 'text') {
+                this.log('Logging in...');
+            }
+            const response = await this.loginWithApiKey(apiKey);
+            if (response.success) {
+                if (format === 'json') {
+                    writeJsonResponse({ command: 'login', data: { userEmail: response.userEmail }, success: true });
+                }
+                else {
+                    this.log(`Logged in as ${response.userEmail}`);
+                }
+            }
+            else {
+                const errorMessage = response.error ?? 'Authentication failed';
+                if (format === 'json') {
+                    writeJsonResponse({ command: 'login', data: { error: errorMessage }, success: false });
+                }
+                else {
+                    this.log(errorMessage);
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Login failed';
+            if (format === 'json') {
+                writeJsonResponse({ command: 'login', data: { error: errorMessage }, success: false });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
     }
 }

package/dist/oclif/commands/main.d.ts

@@ -2,10 +2,9 @@ import { Command } from '@oclif/core';
 /**
  * Main command - Entry point for ByteRover CLI.
  *
- * Architecture v0.5.0:
- * - Main Process: Spawns Transport and Agent processes
- * - TUI discovers Transport via TransportClientFactory (same as external CLIs)
- * - All task communication via Socket.IO (NO IPC)
+ * Ensures the global daemon is running, then starts the interactive REPL.
+ * The daemon manages the transport server and agent pool (forked child processes).
+ * TUI connects to the daemon via TransportClientFactory.
  */
 export default class Main extends Command {
     static description: string;
@@ -14,17 +13,4 @@ export default class Main extends Command {
      */
     static hidden: boolean;
     run(): Promise<void>;
-    /**
-     * Resolve session ID for the agent.
-     *
-     * Strategy:
-     * 1. Check for active session in .brv/sessions/active.json
-     * 2. If active session exists and is valid (not stale), resume it
-     * 3. If stale (process crashed), mark as interrupted and create new
-     * 4. If no active session, create new session
-     * 5. Run session cleanup on startup
-     *
-     * @returns Session ID to use
-     */
-    private resolveSessionId;
 }

package/dist/oclif/commands/main.js

@@ -1,26 +1,13 @@
+import { ensureDaemonRunning } from '@campfirein/brv-transport-client';
 import { Command } from '@oclif/core';
-import { randomUUID } from 'node:crypto';
-import { DEFAULT_SESSION_RETENTION } from '../../agent/core/domain/session/session-metadata.js';
-import { SessionMetadataStore } from '../../agent/infra/session/session-metadata-store.js';
-import { ProjectConfigStore } from '../../server/infra/config/file-config-store.js';
-import { ConnectorManager } from '../../server/infra/connectors/connector-manager.js';
-import { RuleTemplateService } from '../../server/infra/connectors/shared/template-service.js';
-import { FsFileService } from '../../server/infra/file/fs-file-service.js';
-import { getProcessManager } from '../../server/infra/process/index.js';
-import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
-import { FileOnboardingPreferenceStore } from '../../server/infra/storage/file-onboarding-preference-store.js';
-import { createTokenStore } from '../../server/infra/storage/token-store.js';
-import { FsTemplateLoader } from '../../server/infra/template/fs-template-loader.js';
-import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
-import { initSessionLog, processManagerLog } from '../../server/utils/process-logger.js';
+import { resolveLocalServerMainPath } from '../../server/utils/server-main-resolver.js';
 import { startRepl } from '../../tui/repl-startup.js';
 /**
  * Main command - Entry point for ByteRover CLI.
  *
- * Architecture v0.5.0:
- * - Main Process: Spawns Transport and Agent processes
- * - TUI discovers Transport via TransportClientFactory (same as external CLIs)
- * - All task communication via Socket.IO (NO IPC)
+ * Ensures the global daemon is running, then starts the interactive REPL.
+ * The daemon manages the transport server and agent pool (forked child processes).
+ * TUI connects to the daemon via TransportClientFactory.
  */
 export default class Main extends Command {
     static description = 'ByteRover CLI - Interactive REPL';
@@ -29,92 +16,24 @@ export default class Main extends Command {
      */
     static hidden = true;
     async run() {
-        // Initialize session log (creates ~/.brv/logs/brv-{timestamp}.log)
-        initSessionLog();
         // Check if running in an interactive terminal
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
             this.log('ByteRover REPL requires an interactive terminal.');
             this.log("Run 'brv --help' for available commands.");
             return;
         }
-        // Resolve session ID (auto-resume or create new)
-        const sessionId = await this.resolveSessionId();
-        processManagerLog(`Session ID resolved: ${sessionId}`);
-        // Start Transport and Agent processes (v0.5.0 architecture)
-        // Pass session ID to Agent via environment variable
-        const processManager = getProcessManager();
-        await processManager.start({ sessionId });
-        const tokenStore = createTokenStore();
-        const globalConfigStore = new FileGlobalConfigStore();
-        const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
-        const onboardingPreferenceStore = new FileOnboardingPreferenceStore();
-        // Create ConnectorManager for orphaned connector migration at REPL startup
-        const fileService = new FsFileService();
-        const templateLoader = new FsTemplateLoader(fileService);
-        const templateService = new RuleTemplateService(templateLoader);
-        const connectorManager = new ConnectorManager({
-            fileService,
-            projectRoot: process.cwd(),
-            templateService,
+        // Pre-flight: ensure daemon is running (spawn if needed, restart on version mismatch)
+        const daemonResult = await ensureDaemonRunning({
+            serverPath: resolveLocalServerMainPath(),
+            version: this.config.version,
         });
-        // Start the interactive REPL
-        // TUI will discover Transport via TransportClientFactory (same as external CLIs)
-        try {
-            await startRepl({
-                connectorManager,
-                onboardingPreferenceStore,
-                projectConfigStore: new ProjectConfigStore(),
-                tokenStore,
-                trackingService,
-                version: this.config.version,
-            });
+        if (!daemonResult.success) {
+            const detail = daemonResult.spawnError ? `: ${daemonResult.spawnError}` : '';
+            this.error(`Failed to start daemon: timed out waiting for daemon to become ready${detail}\n\nRun 'brv restart' to force a clean restart.`);
         }
-        finally {
-            await processManager.stop();
-        }
-    }
-    /**
-     * Resolve session ID for the agent.
-     *
-     * Strategy:
-     * 1. Check for active session in .brv/sessions/active.json
-     * 2. If active session exists and is valid (not stale), resume it
-     * 3. If stale (process crashed), mark as interrupted and create new
-     * 4. If no active session, create new session
-     * 5. Run session cleanup on startup
-     *
-     * @returns Session ID to use
-     */
-    async resolveSessionId() {
-        const sessionStore = new SessionMetadataStore();
-        // Run cleanup on startup (async, don't wait)
-        sessionStore.cleanupSessions(DEFAULT_SESSION_RETENTION).catch((error) => {
-            processManagerLog(`Session cleanup failed: ${error}`);
+        // Start the interactive REPL (TUI connects via connectToDaemon internally)
+        await startRepl({
+            version: this.config.version,
         });
-        // Check for active session
-        const activeSession = await sessionStore.getActiveSession();
-        if (activeSession) {
-            // Check if the active session is stale (process not running)
-            const isStale = await sessionStore.isActiveSessionStale();
-            if (isStale) {
-                // Mark the old session as interrupted
-                processManagerLog(`Active session ${activeSession.sessionId} is stale, marking as interrupted`);
-                await sessionStore.markSessionInterrupted(activeSession.sessionId);
-            }
-            else {
-                // Valid active session - resume it
-                processManagerLog(`Resuming active session: ${activeSession.sessionId}`);
-                return activeSession.sessionId;
-            }
-        }
-        // Create new session
-        const newSessionId = `agent-session-${randomUUID()}`;
-        processManagerLog(`Creating new session: ${newSessionId}`);
-        // Save session metadata
-        const metadata = sessionStore.createSessionMetadata(newSessionId);
-        await sessionStore.saveSession(metadata);
-        // Set as active session
-        await sessionStore.setActiveSession(newSessionId);
-        return newSessionId;
     }
 }

package/dist/oclif/commands/mcp.js

@@ -1,6 +1,8 @@
 import { NoInstanceRunningError } from '@campfirein/brv-transport-client';
 import { Command } from '@oclif/core';
+import { join } from 'node:path';
 import { ByteRoverMcpServer } from '../../server/infra/mcp/index.js';
+import { getGlobalDataDir } from '../../server/utils/global-data-path.js';
 /**
  * MCP command - starts the MCP server for coding agent integration.
  *
@@ -10,9 +12,6 @@ import { ByteRoverMcpServer } from '../../server/infra/mcp/index.js';
 export default class Mcp extends Command {
     static description = `Start MCP server for coding agent integration
 
-Connects to a running brv instance via Socket.IO.
-Requires: brv running in another terminal.
-
 Exposes tools:
 - brv-query: Query the context tree
 - brv-curate: Curate context to the tree`;
@@ -22,6 +21,17 @@ Exposes tools:
     ];
     static hidden = true; // Called by agents, not users directly
     async run() {
+        // Prevent silent crashes — log to stderr so Windsurf/Cursor/Claude can surface the error
+        const logError = (label, error) => {
+            const msg = error instanceof Error ? error.stack ?? error.message : String(error);
+            process.stderr.write(`[brv-mcp] ${label}: ${msg}\n`);
+        };
+        process.on('uncaughtException', (error) => {
+            logError('Uncaught exception', error);
+        });
+        process.on('unhandledRejection', (reason) => {
+            logError('Unhandled rejection', reason);
+        });
         try {
             const server = new ByteRoverMcpServer({
                 version: this.config.version,
@@ -49,9 +59,18 @@ Exposes tools:
             await server.stop();
         }
         catch (error) {
+            if (error instanceof Error && error.message.startsWith('Failed to start daemon')) {
+                this.logToStderr(`Error: ${error.message}`);
+                this.logToStderr(`Check daemon logs at: ${join(getGlobalDataDir(), 'logs')}`);
+                this.logToStderr("Run 'brv restart' to force a clean restart.");
+                // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+                process.exit(1);
+            }
             if (error instanceof NoInstanceRunningError) {
-                this.logToStderr('Error: No ByteRover instance running.');
-                this.logToStderr('Start one with: brv');
+                this.logToStderr('Error: Daemon was started but connection failed.');
+                this.logToStderr('The daemon may have crashed immediately after starting.');
+                this.logToStderr(`Check daemon logs at: ${join(getGlobalDataDir(), 'logs')}`);
+                this.logToStderr("Run 'brv restart' to force a clean restart.");
                 // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
                 process.exit(1);
             }

package/dist/oclif/commands/model/index.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { type DaemonClientOptions } from '../../lib/daemon-client.js';
+export default class Model extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected fetchActiveModel(options?: DaemonClientOptions): Promise<{
+        activeModel: string | undefined;
+        providerId: string;
+        providerName: string;
+    }>;
+    run(): Promise<void>;
+}

package/dist/oclif/commands/model/index.js

@@ -0,0 +1,59 @@
+import { Command, Flags } from '@oclif/core';
+import { ProviderEvents, } from '../../../shared/transport/events/provider-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../lib/json-response.js';
+export default class Model extends Command {
+    static description = 'Show the active model';
+    static examples = [
+        '<%= config.bin %> model',
+        '<%= config.bin %> model --format json',
+    ];
+    static flags = {
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+    };
+    async fetchActiveModel(options) {
+        return withDaemonRetry(async (client) => {
+            const active = await client.requestWithAck(ProviderEvents.GET_ACTIVE);
+            const { providers } = await client.requestWithAck(ProviderEvents.LIST);
+            const provider = providers.find((p) => p.id === active.activeProviderId);
+            return {
+                activeModel: active.activeModel,
+                providerId: active.activeProviderId,
+                providerName: provider?.name ?? active.activeProviderId,
+            };
+        }, options);
+    }
+    async run() {
+        const { flags } = await this.parse(Model);
+        const format = flags.format;
+        try {
+            const info = await this.fetchActiveModel();
+            if (format === 'json') {
+                writeJsonResponse({ command: 'model', data: info, success: true });
+            }
+            else if (info.providerId === 'byterover') {
+                this.log('You are using ByteRover provider, which runs on its own internal LLM model.');
+            }
+            else if (info.activeModel) {
+                this.log(`Model: ${info.activeModel}`);
+                this.log(`Provider: ${info.providerName} (${info.providerId})`);
+            }
+            else {
+                this.log(`No model set for ${info.providerName} (${info.providerId}).`);
+                this.log('Run "brv model list" to see available models, or "brv model switch <model>" to set one.');
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({ command: 'model', data: { error: formatConnectionError(error) }, success: false });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+}

package/dist/oclif/commands/model/list.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+import { type DaemonClientOptions } from '../../lib/daemon-client.js';
+export default class ModelList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected fetchModels(providerFlag?: string, options?: DaemonClientOptions): Promise<{
+        activeModel: string | undefined;
+        activeProviderId: string;
+        models: import("../../../shared/transport/types/dto.js").ModelDTO[];
+        providerErrors: Record<string, string> | undefined;
+    }>;
+    run(): Promise<void>;
+}