byterover-cli 1.7.2 → 2.0.0

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

@@ -0,0 +1,101 @@
+import { ProviderEvents, } from '../../../../shared/transport/events/provider-events.js';
+import { getProviderById, getProvidersSortedByPriority, providerRequiresApiKey, } from '../../../core/domain/entities/provider-registry.js';
+import { TransportDaemonEventNames } from '../../../core/domain/transport/schemas.js';
+import { getErrorMessage } from '../../../utils/error-helpers.js';
+import { processLog } from '../../../utils/process-logger.js';
+import { validateApiKey as validateApiKeyViaFetcher } from '../../http/provider-model-fetcher-registry.js';
+/**
+ * Handles provider:* events.
+ * Business logic for provider management — no terminal/UI calls.
+ */
+export class ProviderHandler {
+    providerConfigStore;
+    providerKeychainStore;
+    transport;
+    constructor(deps) {
+        this.providerConfigStore = deps.providerConfigStore;
+        this.providerKeychainStore = deps.providerKeychainStore;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.setupConnect();
+        this.setupDisconnect();
+        this.setupGetActive();
+        this.setupList();
+        this.setupSetActive();
+        this.setupValidateApiKey();
+    }
+    setupConnect() {
+        this.transport.onRequest(ProviderEvents.CONNECT, async (data) => {
+            const { apiKey, baseUrl, providerId } = data;
+            // Store API key if provided (supports optional keys for openai-compatible)
+            if (apiKey) {
+                await this.providerKeychainStore.setApiKey(providerId, apiKey);
+            }
+            const provider = getProviderById(providerId);
+            await this.providerConfigStore.connectProvider(providerId, {
+                activeModel: provider?.defaultModel,
+                baseUrl,
+            });
+            this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+            return { success: true };
+        });
+    }
+    setupDisconnect() {
+        this.transport.onRequest(ProviderEvents.DISCONNECT, async (data) => {
+            const { providerId } = data;
+            await this.providerConfigStore.disconnectProvider(providerId);
+            await this.providerKeychainStore.deleteApiKey(providerId);
+            this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+            return { success: true };
+        });
+    }
+    setupGetActive() {
+        this.transport.onRequest(ProviderEvents.GET_ACTIVE, async () => {
+            const activeProviderId = await this.providerConfigStore.getActiveProvider();
+            const activeModel = await this.providerConfigStore.getActiveModel(activeProviderId);
+            return { activeModel, activeProviderId };
+        });
+    }
+    setupList() {
+        this.transport.onRequest(ProviderEvents.LIST, async () => {
+            const definitions = getProvidersSortedByPriority();
+            const activeProviderId = await this.providerConfigStore.getActiveProvider().catch((error) => {
+                processLog(`[ProviderHandler] getActiveProvider failed: ${error instanceof Error ? error.message : String(error)}`);
+                return '';
+            });
+            const providers = await Promise.all(definitions.map(async (def) => ({
+                apiKeyUrl: def.apiKeyUrl,
+                category: def.category,
+                description: def.description,
+                id: def.id,
+                isConnected: await this.providerConfigStore.isProviderConnected(def.id).catch((error) => {
+                    processLog(`[ProviderHandler] isProviderConnected failed for ${def.id}: ${error instanceof Error ? error.message : String(error)}`);
+                    return false;
+                }),
+                isCurrent: def.id === activeProviderId,
+                name: def.name,
+                requiresApiKey: providerRequiresApiKey(def.id),
+            })));
+            return { providers };
+        });
+    }
+    setupSetActive() {
+        this.transport.onRequest(ProviderEvents.SET_ACTIVE, async (data) => {
+            await this.providerConfigStore.setActiveProvider(data.providerId);
+            this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+            return { success: true };
+        });
+    }
+    setupValidateApiKey() {
+        this.transport.onRequest(ProviderEvents.VALIDATE_API_KEY, async (data) => {
+            try {
+                const result = await validateApiKeyViaFetcher(data.apiKey, data.providerId);
+                return result;
+            }
+            catch (error) {
+                return { error: getErrorMessage(error), isValid: false };
+            }
+        });
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.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 { 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 PullHandlerDeps {
+    broadcastToProject: ProjectBroadcaster;
+    cogitPullService: ICogitPullService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    contextTreeWriterService: IContextTreeWriterService;
+    projectConfigStore: IProjectConfigStore;
+    resolveProjectPath: ProjectPathResolver;
+    tokenStore: ITokenStore;
+    transport: ITransportServer;
+}
+/**
+ * Handles pull:* events.
+ * Business logic for pulling context tree from cloud — no terminal/UI calls.
+ */
+export declare class PullHandler {
+    private readonly broadcastToProject;
+    private readonly cogitPullService;
+    private readonly contextTreeSnapshotService;
+    private readonly contextTreeWriterService;
+    private readonly projectConfigStore;
+    private readonly resolveProjectPath;
+    private readonly tokenStore;
+    private readonly transport;
+    constructor(deps: PullHandlerDeps);
+    setup(): void;
+    private handleExecute;
+    private handlePrepare;
+}

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

@@ -0,0 +1,87 @@
+import { PullEvents, } from '../../../../shared/transport/events/pull-events.js';
+import { LocalChangesExistError, NotAuthenticatedError, ProjectNotInitError, SpaceNotConfiguredError, } from '../../../core/domain/errors/task-error.js';
+import { hasAnyChanges, resolveRequiredProjectPath } from './handler-types.js';
+/**
+ * Handles pull:* events.
+ * Business logic for pulling context tree from cloud — no terminal/UI calls.
+ */
+export class PullHandler {
+    broadcastToProject;
+    cogitPullService;
+    contextTreeSnapshotService;
+    contextTreeWriterService;
+    projectConfigStore;
+    resolveProjectPath;
+    tokenStore;
+    transport;
+    constructor(deps) {
+        this.broadcastToProject = deps.broadcastToProject;
+        this.cogitPullService = deps.cogitPullService;
+        this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.contextTreeWriterService = deps.contextTreeWriterService;
+        this.projectConfigStore = deps.projectConfigStore;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.tokenStore = deps.tokenStore;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(PullEvents.PREPARE, (data, clientId) => this.handlePrepare(data, clientId));
+        this.transport.onRequest(PullEvents.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();
+        }
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new ProjectNotInitError();
+        }
+        if (!config.teamId || !config.spaceId) {
+            throw new SpaceNotConfiguredError();
+        }
+        // Check for local changes that would be overwritten
+        const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        if (hasAnyChanges(changes)) {
+            throw new LocalChangesExistError();
+        }
+        this.broadcastToProject(projectPath, PullEvents.PROGRESS, { message: 'Pulling from cloud...', step: 'pulling' });
+        const snapshot = await this.cogitPullService.pull({
+            branch: data.branch,
+            sessionKey: token.sessionKey,
+            spaceId: config.spaceId,
+            teamId: config.teamId,
+        });
+        this.broadcastToProject(projectPath, PullEvents.PROGRESS, { message: 'Syncing files...', step: 'syncing' });
+        const syncResult = await this.contextTreeWriterService.sync({ directory: projectPath, files: snapshot.files });
+        await this.contextTreeSnapshotService.saveSnapshot(projectPath);
+        return {
+            added: syncResult.added.length,
+            commitSha: snapshot.commitSha,
+            deleted: syncResult.deleted.length,
+            edited: syncResult.edited.length,
+            success: true,
+        };
+    }
+    async handlePrepare(_data, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const token = await this.tokenStore.load();
+        if (!token || !token.isValid()) {
+            throw new NotAuthenticatedError();
+        }
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new ProjectNotInitError();
+        }
+        if (!config.teamId || !config.spaceId) {
+            throw new SpaceNotConfiguredError();
+        }
+        const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        const hasLocalChanges = hasAnyChanges(changes);
+        return {
+            hasChanges: hasLocalChanges,
+            summary: hasLocalChanges ? 'Local changes exist. Push first or reset before pulling.' : 'Ready to pull',
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
+import type { IContextFileReader } from '../../../core/interfaces/context-tree/i-context-file-reader.js';
+import type { IContextTreeSnapshotService } from '../../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
+import type { ICogitPushService } from '../../../core/interfaces/services/i-cogit-push-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 PushHandlerDeps {
+    broadcastToProject: ProjectBroadcaster;
+    cogitPushService: ICogitPushService;
+    contextFileReader: IContextFileReader;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    projectConfigStore: IProjectConfigStore;
+    resolveProjectPath: ProjectPathResolver;
+    tokenStore: ITokenStore;
+    transport: ITransportServer;
+    webAppUrl: string;
+}
+/**
+ * Handles push:* events.
+ * Business logic for pushing context tree to cloud — no terminal/UI calls.
+ */
+export declare class PushHandler {
+    private readonly broadcastToProject;
+    private readonly cogitPushService;
+    private readonly contextFileReader;
+    private readonly contextTreeSnapshotService;
+    private readonly projectConfigStore;
+    private readonly resolveProjectPath;
+    private readonly tokenStore;
+    private readonly transport;
+    private readonly webAppUrl;
+    constructor(deps: PushHandlerDeps);
+    setup(): void;
+    private handleExecute;
+    private handlePrepare;
+}

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

@@ -0,0 +1,109 @@
+import { PushEvents, } from '../../../../shared/transport/events/push-events.js';
+import { NotAuthenticatedError, ProjectNotInitError, SpaceNotConfiguredError, } from '../../../core/domain/errors/task-error.js';
+import { mapToPushContexts } from '../../cogit/context-tree-to-push-context-mapper.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+/**
+ * Handles push:* events.
+ * Business logic for pushing context tree to cloud — no terminal/UI calls.
+ */
+export class PushHandler {
+    broadcastToProject;
+    cogitPushService;
+    contextFileReader;
+    contextTreeSnapshotService;
+    projectConfigStore;
+    resolveProjectPath;
+    tokenStore;
+    transport;
+    webAppUrl;
+    constructor(deps) {
+        this.broadcastToProject = deps.broadcastToProject;
+        this.cogitPushService = deps.cogitPushService;
+        this.contextFileReader = deps.contextFileReader;
+        this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.projectConfigStore = deps.projectConfigStore;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.tokenStore = deps.tokenStore;
+        this.transport = deps.transport;
+        this.webAppUrl = deps.webAppUrl;
+    }
+    setup() {
+        this.transport.onRequest(PushEvents.PREPARE, (data, clientId) => this.handlePrepare(data, clientId));
+        this.transport.onRequest(PushEvents.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();
+        }
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new ProjectNotInitError();
+        }
+        if (!config.teamId || !config.spaceId) {
+            throw new SpaceNotConfiguredError();
+        }
+        this.broadcastToProject(projectPath, PushEvents.PROGRESS, { message: 'Reading context files...', step: 'reading' });
+        const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        const [addedFiles, modifiedFiles] = await Promise.all([
+            this.contextFileReader.readMany(changes.added, projectPath),
+            this.contextFileReader.readMany(changes.modified, projectPath),
+        ]);
+        const pushContexts = mapToPushContexts({
+            addedFiles,
+            deletedPaths: changes.deleted,
+            modifiedFiles,
+        });
+        this.broadcastToProject(projectPath, PushEvents.PROGRESS, { message: 'Pushing to cloud...', step: 'pushing' });
+        await this.cogitPushService.push({
+            accessToken: token.accessToken,
+            branch: data.branch,
+            contexts: pushContexts,
+            sessionKey: token.sessionKey,
+            spaceId: config.spaceId,
+            teamId: config.teamId,
+        });
+        await this.contextTreeSnapshotService.saveSnapshot(projectPath);
+        const url = `${this.webAppUrl}/${config.teamName}/${config.spaceName}`;
+        return {
+            added: addedFiles.length,
+            deleted: changes.deleted.length,
+            edited: modifiedFiles.length,
+            success: true,
+            url,
+        };
+    }
+    async handlePrepare(_data, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const token = await this.tokenStore.load();
+        if (!token || !token.isValid()) {
+            throw new NotAuthenticatedError();
+        }
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new ProjectNotInitError();
+        }
+        if (!config.teamId || !config.spaceId) {
+            throw new SpaceNotConfiguredError();
+        }
+        const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(projectPath);
+        if (!hasSnapshot) {
+            await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+        }
+        const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        const totalChanges = changes.added.length + changes.modified.length + changes.deleted.length;
+        const parts = [];
+        if (changes.added.length > 0)
+            parts.push(`${changes.added.length} added`);
+        if (changes.modified.length > 0)
+            parts.push(`${changes.modified.length} modified`);
+        if (changes.deleted.length > 0)
+            parts.push(`${changes.deleted.length} deleted`);
+        return {
+            fileCount: totalChanges,
+            hasChanges: totalChanges > 0,
+            summary: parts.length > 0 ? parts.join(', ') : 'No changes',
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+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 { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import { type ProjectPathResolver } from './handler-types.js';
+export interface ResetHandlerDeps {
+    contextTreeService: IContextTreeService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    resolveProjectPath: ProjectPathResolver;
+    transport: ITransportServer;
+}
+/**
+ * Handles reset:execute event.
+ * Deletes and re-initializes the context tree — no terminal/UI calls.
+ */
+export declare class ResetHandler {
+    private readonly contextTreeService;
+    private readonly contextTreeSnapshotService;
+    private readonly resolveProjectPath;
+    private readonly transport;
+    constructor(deps: ResetHandlerDeps);
+    setup(): void;
+    private handleExecute;
+}

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

@@ -0,0 +1,33 @@
+import { ResetEvents } from '../../../../shared/transport/events/reset-events.js';
+import { ContextTreeNotInitializedError } from '../../../core/domain/errors/task-error.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+/**
+ * Handles reset:execute event.
+ * Deletes and re-initializes the context tree — no terminal/UI calls.
+ */
+export class ResetHandler {
+    contextTreeService;
+    contextTreeSnapshotService;
+    resolveProjectPath;
+    transport;
+    constructor(deps) {
+        this.contextTreeService = deps.contextTreeService;
+        this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(ResetEvents.EXECUTE, (_data, clientId) => this.handleExecute(clientId));
+    }
+    async handleExecute(clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const exists = await this.contextTreeService.exists(projectPath);
+        if (!exists) {
+            throw new ContextTreeNotInitializedError();
+        }
+        await this.contextTreeService.delete(projectPath);
+        await this.contextTreeService.initialize(projectPath);
+        await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+        return { success: true };
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
+import type { IContextTreeMerger } from '../../../core/interfaces/context-tree/i-context-tree-merger.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 SpaceHandlerDeps {
+    broadcastToProject: ProjectBroadcaster;
+    cogitPullService: ICogitPullService;
+    contextTreeMerger: IContextTreeMerger;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    contextTreeWriterService: IContextTreeWriterService;
+    projectConfigStore: IProjectConfigStore;
+    resolveProjectPath: ProjectPathResolver;
+    spaceService: ISpaceService;
+    teamService: ITeamService;
+    tokenStore: ITokenStore;
+    transport: ITransportServer;
+}
+/**
+ * Handles space:* events.
+ * Business logic for space listing and switching — no terminal/UI calls.
+ */
+export declare class SpaceHandler {
+    private readonly broadcastToProject;
+    private readonly cogitPullService;
+    private readonly contextTreeMerger;
+    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: SpaceHandlerDeps);
+    setup(): void;
+    private handleList;
+    private handleSwitch;
+}