byterover-cli 1.7.2 → 2.0.0

package/dist/server/infra/transport/handlers/hub-handler.js

@@ -0,0 +1,218 @@
+import { HubEvents, } from '../../../../shared/transport/events/hub-events.js';
+import { isAgent } from '../../../core/domain/entities/agent.js';
+import { CompositeHubRegistryService } from '../../hub/composite-hub-registry-service.js';
+import { HubRegistryService } from '../../hub/hub-registry-service.js';
+const OFFICIAL_REGISTRY_NAME = 'official';
+const RESERVED_REGISTRY_NAMES = new Set(['brv', 'byterover', 'campfire', 'campfirein', 'official']);
+export class HubHandler {
+    hubInstallService;
+    hubKeychainStore;
+    hubRegistryConfigStore;
+    hubRegistryService;
+    officialRegistryUrl;
+    registryTimeoutMs;
+    resolveProjectPath;
+    transport;
+    constructor(deps) {
+        this.hubInstallService = deps.hubInstallService;
+        this.hubKeychainStore = deps.hubKeychainStore;
+        this.hubRegistryConfigStore = deps.hubRegistryConfigStore;
+        this.officialRegistryUrl = deps.officialRegistryUrl;
+        this.registryTimeoutMs = deps.registryTimeoutMs;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.transport = deps.transport;
+        // Will be built during setup
+        this.hubRegistryService = new HubRegistryService({
+            name: OFFICIAL_REGISTRY_NAME,
+            timeoutMs: this.registryTimeoutMs,
+            url: deps.officialRegistryUrl,
+        });
+    }
+    async setup() {
+        await this.rebuildRegistryService();
+        this.transport.onRequest(HubEvents.LIST, () => this.handleList());
+        this.transport.onRequest(HubEvents.INSTALL, (data, clientId) => this.handleInstall(data, clientId));
+        this.transport.onRequest(HubEvents.REGISTRY_ADD, (data) => this.handleRegistryAdd(data));
+        this.transport.onRequest(HubEvents.REGISTRY_REMOVE, (data) => this.handleRegistryRemove(data));
+        this.transport.onRequest(HubEvents.REGISTRY_LIST, () => this.handleRegistryList());
+    }
+    async handleInstall(data, clientId) {
+        const agent = data.agent && isAgent(data.agent) ? data.agent : undefined;
+        if (data.agent && !agent) {
+            return { installedFiles: [], installedPath: '', message: `Invalid agent: ${data.agent}`, success: false };
+        }
+        const projectPath = this.resolveEffectivePath(clientId);
+        const scope = data.scope ?? 'project';
+        const matches = await this.hubRegistryService.getEntriesById(data.entryId).then((entries) => {
+            // If a specific registry is requested, filter to that registry
+            if (data.registry) {
+                return entries.filter((entry) => entry.registry === data.registry);
+            }
+            return entries;
+        });
+        switch (matches.length) {
+            case 0: {
+                return { installedFiles: [], installedPath: '', message: `Entry not found: ${data.entryId}`, success: false };
+            }
+            case 1: {
+                // Single match: proceed with install
+                return this.performInstall(matches[0], projectPath, agent, scope);
+            }
+            default: {
+                // Multiple matches: detect duplicates
+                const registryNames = matches.map((m) => m.registry ?? 'unknown').join(', ');
+                return {
+                    installedFiles: [],
+                    installedPath: '',
+                    message: `'${data.entryId}' exists in multiple registries: ${registryNames}. Specify one with --registry <name>.`,
+                    success: false,
+                };
+            }
+        }
+    }
+    async handleList() {
+        this.transport.broadcast(HubEvents.LIST_PROGRESS, { message: 'Fetching hub entries...', step: 'fetching' });
+        const { entries, version } = await this.hubRegistryService.getEntries();
+        return { entries, version };
+    }
+    async handleRegistryAdd(data) {
+        try {
+            if (RESERVED_REGISTRY_NAMES.has(data.name.toLowerCase())) {
+                return { message: `Registry name '${data.name}' is reserved`, success: false };
+            }
+            // Validate registry is reachable and returns valid data before persisting
+            this.transport.broadcast(HubEvents.REGISTRY_ADD_PROGRESS, { message: 'Validating registry...', step: 'validating' });
+            const probeService = new HubRegistryService({
+                authScheme: data.authScheme,
+                authToken: data.token,
+                headerName: data.headerName,
+                name: data.name,
+                timeoutMs: this.registryTimeoutMs,
+                url: data.url,
+            });
+            await probeService.getEntries();
+            this.transport.broadcast(HubEvents.REGISTRY_ADD_PROGRESS, { message: 'Saving registry...', step: 'saving' });
+            await this.hubRegistryConfigStore.addRegistry({
+                ...(data.authScheme ? { authScheme: data.authScheme } : {}),
+                ...(data.headerName ? { headerName: data.headerName } : {}),
+                name: data.name,
+                url: data.url,
+            });
+            if (data.token) {
+                await this.hubKeychainStore.setToken(data.name, data.token);
+            }
+            await this.rebuildRegistryService();
+            return { message: `Registry '${data.name}' added successfully`, success: true };
+        }
+        catch (error) {
+            return {
+                message: `Failed to add registry: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                success: false,
+            };
+        }
+    }
+    async handleRegistryList() {
+        this.transport.broadcast(HubEvents.REGISTRY_LIST_PROGRESS, { message: 'Checking registries...', step: 'checking' });
+        const registries = await this.hubRegistryConfigStore.getRegistries();
+        const allConfigs = [
+            { authScheme: 'none', hasToken: false, name: OFFICIAL_REGISTRY_NAME, url: this.officialRegistryUrl },
+            ...(await Promise.all(registries.map(async (r) => ({
+                authScheme: (r.authScheme ?? 'bearer'),
+                hasToken: (await this.hubKeychainStore.getToken(r.name)) !== undefined,
+                name: r.name,
+                url: r.url,
+            })))),
+        ];
+        const results = await Promise.all(allConfigs.map(async (config) => {
+            try {
+                const authToken = await this.hubKeychainStore.getToken(config.name);
+                const probe = new HubRegistryService({
+                    authScheme: config.authScheme,
+                    authToken,
+                    name: config.name,
+                    timeoutMs: this.registryTimeoutMs,
+                    url: config.url,
+                });
+                const { entries } = await probe.getEntries();
+                return { ...config, entryCount: entries.length, status: 'ok' };
+            }
+            catch (error) {
+                return {
+                    ...config,
+                    entryCount: 0,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    status: 'error',
+                };
+            }
+        }));
+        return { registries: results };
+    }
+    async handleRegistryRemove(data) {
+        try {
+            await this.hubRegistryConfigStore.removeRegistry(data.name);
+            await this.hubKeychainStore.deleteToken(data.name);
+            await this.rebuildRegistryService();
+            return { message: `Registry '${data.name}' removed successfully`, success: true };
+        }
+        catch (error) {
+            return {
+                message: `Failed to remove registry: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                success: false,
+            };
+        }
+    }
+    async performInstall(entry, projectPath, agent, scope) {
+        try {
+            let auth;
+            if (entry.registry && entry.registry !== OFFICIAL_REGISTRY_NAME) {
+                const registries = await this.hubRegistryConfigStore.getRegistries();
+                const registryConfig = registries.find((r) => r.name === entry.registry);
+                const authToken = (await this.hubKeychainStore.getToken(entry.registry)) ?? undefined;
+                auth = {
+                    authScheme: registryConfig?.authScheme,
+                    authToken,
+                    headerName: registryConfig?.headerName,
+                };
+            }
+            const result = await this.hubInstallService.install({ agent, auth, entry, projectPath, scope });
+            const registryLabel = entry.registry ? ` [${entry.registry}]` : '';
+            return {
+                installedFiles: result.installedFiles,
+                installedPath: result.installedPath,
+                message: `${result.message}${registryLabel}`,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                installedFiles: [],
+                installedPath: '',
+                message: `Install failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                success: false,
+            };
+        }
+    }
+    async rebuildRegistryService() {
+        const officialChild = new HubRegistryService({
+            name: OFFICIAL_REGISTRY_NAME,
+            timeoutMs: this.registryTimeoutMs,
+            url: this.officialRegistryUrl,
+        });
+        const registries = await this.hubRegistryConfigStore.getRegistries();
+        const privateChildren = await Promise.all(registries.map(async (r) => {
+            const authToken = (await this.hubKeychainStore.getToken(r.name)) ?? undefined;
+            return new HubRegistryService({
+                authScheme: r.authScheme,
+                authToken,
+                headerName: r.headerName,
+                name: r.name,
+                timeoutMs: this.registryTimeoutMs,
+                url: r.url,
+            });
+        }));
+        this.hubRegistryService = new CompositeHubRegistryService([officialChild, ...privateChildren]);
+    }
+    resolveEffectivePath(clientId) {
+        return this.resolveProjectPath(clientId) ?? process.cwd();
+    }
+}

package/dist/server/infra/transport/handlers/index.d.ts

@@ -0,0 +1,26 @@
+export { AuthHandler } from './auth-handler.js';
+export type { AuthHandlerDeps } from './auth-handler.js';
+export { ConfigHandler } from './config-handler.js';
+export type { ConfigHandlerDeps } from './config-handler.js';
+export { ConnectorsHandler } from './connectors-handler.js';
+export type { ConnectorsHandlerDeps } from './connectors-handler.js';
+export type { ProjectBroadcaster, ProjectPathResolver } from './handler-types.js';
+export { resolveRequiredProjectPath } from './handler-types.js';
+export { HubHandler } from './hub-handler.js';
+export type { HubHandlerDeps } from './hub-handler.js';
+export { InitHandler } from './init-handler.js';
+export type { InitHandlerDeps } from './init-handler.js';
+export { ModelHandler } from './model-handler.js';
+export type { ModelHandlerDeps } from './model-handler.js';
+export { ProviderHandler } from './provider-handler.js';
+export type { ProviderHandlerDeps } from './provider-handler.js';
+export { PullHandler } from './pull-handler.js';
+export type { PullHandlerDeps } from './pull-handler.js';
+export { PushHandler } from './push-handler.js';
+export type { PushHandlerDeps } from './push-handler.js';
+export { ResetHandler } from './reset-handler.js';
+export type { ResetHandlerDeps } from './reset-handler.js';
+export { SpaceHandler } from './space-handler.js';
+export type { SpaceHandlerDeps } from './space-handler.js';
+export { StatusHandler } from './status-handler.js';
+export type { StatusHandlerDeps } from './status-handler.js';

package/dist/server/infra/transport/handlers/index.js

@@ -0,0 +1,13 @@
+export { AuthHandler } from './auth-handler.js';
+export { ConfigHandler } from './config-handler.js';
+export { ConnectorsHandler } from './connectors-handler.js';
+export { resolveRequiredProjectPath } from './handler-types.js';
+export { HubHandler } from './hub-handler.js';
+export { InitHandler } from './init-handler.js';
+export { ModelHandler } from './model-handler.js';
+export { ProviderHandler } from './provider-handler.js';
+export { PullHandler } from './pull-handler.js';
+export { PushHandler } from './push-handler.js';
+export { ResetHandler } from './reset-handler.js';
+export { SpaceHandler } from './space-handler.js';
+export { StatusHandler } from './status-handler.js';

package/dist/server/infra/transport/handlers/init-handler.d.ts

@@ -0,0 +1,50 @@
+import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
+import type { IConnectorManager } from '../../../core/interfaces/connectors/i-connector-manager.js';
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
+import type { IContextTreeSnapshotService } from '../../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
+import type { IContextTreeWriterService } from '../../../core/interfaces/context-tree/i-context-tree-writer-service.js';
+import type { ICogitPullService } from '../../../core/interfaces/services/i-cogit-pull-service.js';
+import type { ISpaceService } from '../../../core/interfaces/services/i-space-service.js';
+import type { ITeamService } from '../../../core/interfaces/services/i-team-service.js';
+import type { IProjectConfigStore } from '../../../core/interfaces/storage/i-project-config-store.js';
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import { type ProjectBroadcaster, type ProjectPathResolver } from './handler-types.js';
+export interface InitHandlerDeps {
+    broadcastToProject: ProjectBroadcaster;
+    cogitPullService: ICogitPullService;
+    connectorManagerFactory: (projectRoot: string) => IConnectorManager;
+    contextTreeService: IContextTreeService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    contextTreeWriterService: IContextTreeWriterService;
+    projectConfigStore: IProjectConfigStore;
+    resolveProjectPath: ProjectPathResolver;
+    spaceService: ISpaceService;
+    teamService: ITeamService;
+    tokenStore: ITokenStore;
+    transport: ITransportServer;
+}
+/**
+ * Handles init:* events.
+ * Business logic for project initialization — no terminal/UI calls.
+ * The TUI orchestrates the multi-step UX flow, calling granular events.
+ */
+export declare class InitHandler {
+    private readonly broadcastToProject;
+    private readonly cogitPullService;
+    private readonly connectorManagerFactory;
+    private readonly contextTreeService;
+    private readonly contextTreeSnapshotService;
+    private readonly contextTreeWriterService;
+    private readonly projectConfigStore;
+    private readonly resolveProjectPath;
+    private readonly spaceService;
+    private readonly teamService;
+    private readonly tokenStore;
+    private readonly transport;
+    constructor(deps: InitHandlerDeps);
+    setup(): void;
+    private handleExecute;
+    private handleGetAgents;
+    private handleGetSpaces;
+    private handleGetTeams;
+}

package/dist/server/infra/transport/handlers/init-handler.js

@@ -0,0 +1,157 @@
+import { InitEvents, } from '../../../../shared/transport/events/init-events.js';
+import { isConnectorType } from '../../../../shared/types/connector-type.js';
+import { isAgent } from '../../../core/domain/entities/agent.js';
+import { BrvConfig } from '../../../core/domain/entities/brv-config.js';
+import { NotAuthenticatedError, SpaceNotFoundError } from '../../../core/domain/errors/task-error.js';
+import { syncConfigToXdg } from '../../../utils/config-xdg-sync.js';
+import { getErrorMessage } from '../../../utils/error-helpers.js';
+import { mapAgentsToDTOs } from './agent-dto-mapper.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+/**
+ * Handles init:* events.
+ * Business logic for project initialization — no terminal/UI calls.
+ * The TUI orchestrates the multi-step UX flow, calling granular events.
+ */
+export class InitHandler {
+    broadcastToProject;
+    cogitPullService;
+    connectorManagerFactory;
+    contextTreeService;
+    contextTreeSnapshotService;
+    contextTreeWriterService;
+    projectConfigStore;
+    resolveProjectPath;
+    spaceService;
+    teamService;
+    tokenStore;
+    transport;
+    constructor(deps) {
+        this.broadcastToProject = deps.broadcastToProject;
+        this.cogitPullService = deps.cogitPullService;
+        this.connectorManagerFactory = deps.connectorManagerFactory;
+        this.contextTreeService = deps.contextTreeService;
+        this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.contextTreeWriterService = deps.contextTreeWriterService;
+        this.projectConfigStore = deps.projectConfigStore;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.spaceService = deps.spaceService;
+        this.teamService = deps.teamService;
+        this.tokenStore = deps.tokenStore;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(InitEvents.GET_TEAMS, () => this.handleGetTeams());
+        this.transport.onRequest(InitEvents.GET_SPACES, (data) => this.handleGetSpaces(data));
+        this.transport.onRequest(InitEvents.GET_AGENTS, () => this.handleGetAgents());
+        this.transport.onRequest(InitEvents.EXECUTE, (data, clientId) => this.handleExecute(data, clientId));
+    }
+    async handleExecute(data, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const token = await this.tokenStore.load();
+        if (!token || !token.isValid()) {
+            throw new NotAuthenticatedError();
+        }
+        // Check for existing config
+        if ((await this.projectConfigStore.exists(projectPath)) && !data.force) {
+            throw new Error('Project already initialized. Use force to re-initialize.');
+        }
+        this.broadcastToProject(projectPath, InitEvents.PROGRESS, { message: 'Fetching space...', step: 'fetch_space' });
+        // Find space
+        const { spaces } = await this.spaceService.getSpaces(token.sessionKey, data.teamId, { fetchAll: true });
+        const space = spaces.find((s) => s.id === data.spaceId);
+        if (!space) {
+            throw new SpaceNotFoundError();
+        }
+        this.broadcastToProject(projectPath, InitEvents.PROGRESS, { message: 'Syncing from cloud...', step: 'sync' });
+        // Pull from cloud
+        try {
+            const snapshot = await this.cogitPullService.pull({
+                branch: 'main',
+                sessionKey: token.sessionKey,
+                spaceId: data.spaceId,
+                teamId: data.teamId,
+            });
+            if (snapshot.files.length > 0) {
+                await this.contextTreeWriterService.sync({ directory: projectPath, files: snapshot.files });
+                await this.contextTreeSnapshotService.saveSnapshot(projectPath);
+            }
+            else {
+                await this.contextTreeService.initialize(projectPath);
+                await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+            }
+        }
+        catch {
+            // If pull fails, initialize empty context tree
+            await this.contextTreeService.initialize(projectPath);
+            await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+        }
+        this.broadcastToProject(projectPath, InitEvents.PROGRESS, { message: 'Creating config...', step: 'config' });
+        // Create and write config + XDG clone
+        if (!isAgent(data.agentId)) {
+            throw new Error(`Unsupported agent: ${data.agentId}`);
+        }
+        const brvConfig = BrvConfig.fromSpace({
+            chatLogPath: '',
+            cwd: projectPath,
+            ide: data.agentId,
+            space,
+        });
+        await this.projectConfigStore.write(brvConfig, projectPath);
+        await syncConfigToXdg(brvConfig, projectPath);
+        this.broadcastToProject(projectPath, InitEvents.PROGRESS, { message: 'Installing connector...', step: 'connector' });
+        // Install connector
+        try {
+            if (!isConnectorType(data.connectorType)) {
+                throw new Error(`Unsupported connector type: ${data.connectorType}`);
+            }
+            const connectorManager = this.connectorManagerFactory(projectPath);
+            await connectorManager.switchConnector(data.agentId, data.connectorType);
+        }
+        catch (error) {
+            // Non-fatal: connector installation failure shouldn't block init
+            this.broadcastToProject(projectPath, InitEvents.PROGRESS, {
+                message: `Connector warning: ${getErrorMessage(error)}`,
+                step: 'connector_warning',
+            });
+        }
+        this.broadcastToProject(projectPath, InitEvents.COMPLETED, {
+            config: { spaceName: brvConfig.spaceName, teamName: brvConfig.teamName },
+            success: true,
+        });
+        return { success: true };
+    }
+    handleGetAgents() {
+        return { agents: mapAgentsToDTOs() };
+    }
+    async handleGetSpaces(data) {
+        const token = await this.tokenStore.load();
+        if (!token || !token.isValid()) {
+            throw new NotAuthenticatedError();
+        }
+        const { spaces } = await this.spaceService.getSpaces(token.sessionKey, data.teamId, { fetchAll: true });
+        return {
+            spaces: spaces.map((s) => ({
+                id: s.id,
+                isDefault: s.isDefault,
+                name: s.name,
+                teamId: s.teamId,
+                teamName: s.teamName,
+            })),
+        };
+    }
+    async handleGetTeams() {
+        const token = await this.tokenStore.load();
+        if (!token || !token.isValid()) {
+            throw new NotAuthenticatedError();
+        }
+        const { teams } = await this.teamService.getTeams(token.sessionKey, { fetchAll: true });
+        return {
+            teams: teams.map((t) => ({
+                displayName: t.displayName,
+                id: t.id,
+                isDefault: t.isDefault,
+                name: t.name,
+            })),
+        };
+    }
+}

package/dist/server/infra/transport/handlers/model-handler.d.ts

@@ -0,0 +1,22 @@
+import type { IProviderConfigStore } from '../../../core/interfaces/i-provider-config-store.js';
+import type { IProviderKeychainStore } from '../../../core/interfaces/i-provider-keychain-store.js';
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+export interface ModelHandlerDeps {
+    providerConfigStore: IProviderConfigStore;
+    providerKeychainStore: IProviderKeychainStore;
+    transport: ITransportServer;
+}
+/**
+ * Handles model:* events.
+ * Business logic for model listing and selection — no terminal/UI calls.
+ */
+export declare class ModelHandler {
+    private readonly providerConfigStore;
+    private readonly providerKeychainStore;
+    private readonly transport;
+    constructor(deps: ModelHandlerDeps);
+    setup(): void;
+    private setupList;
+    private setupListByProviders;
+    private setupSetActive;
+}

package/dist/server/infra/transport/handlers/model-handler.js

@@ -0,0 +1,107 @@
+import { ModelEvents, } from '../../../../shared/transport/events/model-events.js';
+import { TransportDaemonEventNames } from '../../../core/domain/transport/schemas.js';
+import { getModelFetcher } from '../../http/provider-model-fetcher-registry.js';
+/**
+ * Handles model:* events.
+ * Business logic for model listing and selection — no terminal/UI calls.
+ */
+export class ModelHandler {
+    providerConfigStore;
+    providerKeychainStore;
+    transport;
+    constructor(deps) {
+        this.providerConfigStore = deps.providerConfigStore;
+        this.providerKeychainStore = deps.providerKeychainStore;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.setupList();
+        this.setupListByProviders();
+        this.setupSetActive();
+    }
+    setupList() {
+        this.transport.onRequest(ModelEvents.LIST, async (data) => {
+            const { providerId } = data;
+            const fetcher = await getModelFetcher(providerId);
+            if (!fetcher) {
+                return { favorites: [], models: [], recent: [] };
+            }
+            // Fetch models from provider API using the correct per-provider fetcher
+            let fetchedModels;
+            try {
+                const apiKey = await this.providerKeychainStore.getApiKey(providerId);
+                fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+            }
+            catch {
+                return { favorites: [], models: [], recent: [] };
+            }
+            const models = fetchedModels.map((m) => ({
+                contextLength: m.contextLength,
+                description: m.description,
+                id: m.id,
+                isFree: m.isFree,
+                name: m.name,
+                pricing: m.pricing,
+                provider: m.provider,
+                providerId,
+            }));
+            const [activeModel, favorites, recent] = await Promise.all([
+                this.providerConfigStore.getActiveModel(providerId),
+                this.providerConfigStore.getFavoriteModels(providerId),
+                this.providerConfigStore.getRecentModels(providerId),
+            ]);
+            return {
+                activeModel,
+                favorites: [...favorites],
+                models,
+                recent: [...recent],
+            };
+        });
+    }
+    setupListByProviders() {
+        this.transport.onRequest(ModelEvents.LIST_BY_PROVIDERS, async (data) => {
+            const { providerIds } = data;
+            const results = await Promise.allSettled(providerIds.map(async (providerId) => {
+                const fetcher = await getModelFetcher(providerId);
+                if (!fetcher)
+                    return [];
+                const apiKey = await this.providerKeychainStore.getApiKey(providerId);
+                const fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+                return fetchedModels.map((model) => ({
+                    contextLength: model.contextLength,
+                    description: model.description,
+                    id: model.id,
+                    isFree: model.isFree,
+                    name: model.name,
+                    pricing: model.pricing,
+                    provider: model.provider,
+                    providerId,
+                }));
+            }));
+            const models = [];
+            const providerErrors = {};
+            for (const [i, result] of results.entries()) {
+                const providerId = providerIds[i];
+                if (result.status === 'fulfilled') {
+                    models.push(...result.value);
+                }
+                else {
+                    const raw = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                    providerErrors[providerId] = raw.replace(/ for event '[^']+'$/, '');
+                }
+            }
+            return {
+                models,
+                providerErrors: Object.keys(providerErrors).length > 0 ? providerErrors : undefined,
+            };
+        });
+    }
+    setupSetActive() {
+        this.transport.onRequest(ModelEvents.SET_ACTIVE, async (data) => {
+            await this.providerConfigStore.setActiveProvider(data.providerId);
+            await this.providerConfigStore.setActiveModel(data.providerId, data.modelId, data.contextLength);
+            this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+            return { success: true };
+        });
+    }
+}

package/dist/server/infra/transport/handlers/provider-handler.d.ts

@@ -0,0 +1,25 @@
+import type { IProviderConfigStore } from '../../../core/interfaces/i-provider-config-store.js';
+import type { IProviderKeychainStore } from '../../../core/interfaces/i-provider-keychain-store.js';
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+export interface ProviderHandlerDeps {
+    providerConfigStore: IProviderConfigStore;
+    providerKeychainStore: IProviderKeychainStore;
+    transport: ITransportServer;
+}
+/**
+ * Handles provider:* events.
+ * Business logic for provider management — no terminal/UI calls.
+ */
+export declare class ProviderHandler {
+    private readonly providerConfigStore;
+    private readonly providerKeychainStore;
+    private readonly transport;
+    constructor(deps: ProviderHandlerDeps);
+    setup(): void;
+    private setupConnect;
+    private setupDisconnect;
+    private setupGetActive;
+    private setupList;
+    private setupSetActive;
+    private setupValidateApiKey;
+}