byterover-cli 2.1.5 → 2.3.0

package/dist/server/infra/provider-oauth/types.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export type ProviderCallbackResult = {
+    code: string;
+    state: string;
+};
+export type PkceParameters = {
+    codeChallenge: string;
+    codeVerifier: string;
+    state: string;
+};
+export type TokenRequestContentType = 'application/json' | 'application/x-www-form-urlencoded';
+/**
+ * Raw token response from an OAuth provider.
+ * Fields are snake_case per OAuth 2.0 spec (RFC 6749).
+ */
+export declare const ProviderTokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+    id_token: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    token_type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+    scope?: string | undefined;
+    refresh_token?: string | undefined;
+    expires_in?: number | undefined;
+    id_token?: string | undefined;
+    token_type?: string | undefined;
+}, {
+    access_token: string;
+    scope?: string | undefined;
+    refresh_token?: string | undefined;
+    expires_in?: number | undefined;
+    id_token?: string | undefined;
+    token_type?: string | undefined;
+}>;
+export type ProviderTokenResponse = z.infer<typeof ProviderTokenResponseSchema>;
+export type RefreshTokenExchangeParams = {
+    clientId: string;
+    contentType: TokenRequestContentType;
+    refreshToken: string;
+    tokenUrl: string;
+};
+export type TokenExchangeParams = {
+    clientId: string;
+    clientSecret?: string;
+    code: string;
+    codeVerifier: string;
+    contentType: TokenRequestContentType;
+    redirectUri: string;
+    tokenUrl: string;
+};
+/** Compute an ISO 8601 expiry timestamp from an OAuth expires_in value (seconds). */
+export declare function computeExpiresAt(expiresInSeconds: number): string;

package/dist/server/infra/provider-oauth/types.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+/**
+ * Raw token response from an OAuth provider.
+ * Fields are snake_case per OAuth 2.0 spec (RFC 6749).
+ */
+export const ProviderTokenResponseSchema = z.object({
+    // eslint-disable-next-line camelcase
+    access_token: z.string().min(1),
+    // eslint-disable-next-line camelcase
+    expires_in: z.number().optional(),
+    // eslint-disable-next-line camelcase
+    id_token: z.string().optional(),
+    // eslint-disable-next-line camelcase
+    refresh_token: z.string().optional(),
+    scope: z.string().optional(),
+    // eslint-disable-next-line camelcase
+    token_type: z.string().optional(),
+});
+/** Compute an ISO 8601 expiry timestamp from an OAuth expires_in value (seconds). */
+export function computeExpiresAt(expiresInSeconds) {
+    return new Date(Date.now() + expiresInSeconds * 1000).toISOString();
+}

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

@@ -31,7 +31,9 @@ export declare class FileProviderConfigStore implements IProviderConfigStore {
      */
     connectProvider(providerId: string, options?: {
         activeModel?: string;
+        authMethod?: 'api-key' | 'oauth';
         baseUrl?: string;
+        oauthAccountId?: string;
     }): Promise<void>;
     /**
      * Removes a provider connection.

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

@@ -38,9 +38,7 @@ export class FileProviderConfigStore {
      */
     async connectProvider(providerId, options) {
         const config = await this.read();
-        const newConfig = config
-            .withProviderConnected(providerId, options)
-            .withActiveProvider(providerId);
+        const newConfig = config.withProviderConnected(providerId, options).withActiveProvider(providerId);
         await this.write(newConfig);
     }
     /**

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

@@ -10,6 +10,8 @@ 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 { LocationsHandler } from './locations-handler.js';
+export type { LocationsHandlerDeps } from './locations-handler.js';
 export { ModelHandler } from './model-handler.js';
 export type { ModelHandlerDeps } from './model-handler.js';
 export { ProviderHandler } from './provider-handler.js';

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

@@ -4,6 +4,7 @@ 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 { LocationsHandler } from './locations-handler.js';
 export { ModelHandler } from './model-handler.js';
 export { ProviderHandler } from './provider-handler.js';
 export { PullHandler } from './pull-handler.js';

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

@@ -0,0 +1,25 @@
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
+import type { IProjectRegistry } from '../../../core/interfaces/project/i-project-registry.js';
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import { type ProjectPathResolver } from './handler-types.js';
+export interface LocationsHandlerDeps {
+    contextTreeService: IContextTreeService;
+    getActiveProjectPaths: () => string[];
+    projectRegistry: IProjectRegistry;
+    resolveProjectPath: ProjectPathResolver;
+    transport: ITransportServer;
+}
+/**
+ * Handles locations:get event.
+ * Returns all registered project locations with context tree status.
+ */
+export declare class LocationsHandler {
+    private readonly contextTreeService;
+    private readonly getActiveProjectPaths;
+    private readonly projectRegistry;
+    private readonly resolveProjectPath;
+    private readonly transport;
+    constructor(deps: LocationsHandlerDeps);
+    setup(): void;
+    private buildLocations;
+}

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

@@ -0,0 +1,64 @@
+import { join } from 'node:path';
+import { LocationsEvents } from '../../../../shared/transport/events/locations-events.js';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../constants.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+/**
+ * Handles locations:get event.
+ * Returns all registered project locations with context tree status.
+ */
+export class LocationsHandler {
+    contextTreeService;
+    getActiveProjectPaths;
+    projectRegistry;
+    resolveProjectPath;
+    transport;
+    constructor(deps) {
+        this.contextTreeService = deps.contextTreeService;
+        this.getActiveProjectPaths = deps.getActiveProjectPaths;
+        this.projectRegistry = deps.projectRegistry;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(LocationsEvents.GET, async (_data, clientId) => {
+            const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            try {
+                const locations = await this.buildLocations(projectPath);
+                return { locations };
+            }
+            catch {
+                return { locations: [] };
+            }
+        });
+    }
+    async buildLocations(currentProjectPath) {
+        const all = this.projectRegistry.getAll();
+        const activeSet = new Set(this.getActiveProjectPaths());
+        const results = await Promise.all([...all.entries()].map(async ([path]) => {
+            let isInitialized = false;
+            try {
+                isInitialized = await this.contextTreeService.exists(path);
+            }
+            catch {
+                // FS error — treat as not initialized
+            }
+            return {
+                contextTreePath: join(path, BRV_DIR, CONTEXT_TREE_DIR),
+                isActive: activeSet.has(path) || path === currentProjectPath,
+                isCurrent: path === currentProjectPath,
+                isInitialized,
+                projectPath: path,
+            };
+        }));
+        // Sort: current first → active (has clients) → initialized → rest, all by registeredAt desc
+        return results.sort((a, b) => {
+            if (a.isCurrent !== b.isCurrent)
+                return a.isCurrent ? -1 : 1;
+            if (a.isActive !== b.isActive)
+                return a.isActive ? -1 : 1;
+            if (a.isInitialized !== b.isInitialized)
+                return a.isInitialized ? -1 : 1;
+            return (all.get(b.projectPath)?.registeredAt ?? 0) - (all.get(a.projectPath)?.registeredAt ?? 0);
+        });
+    }
+}

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

@@ -1,7 +1,9 @@
 import type { IProviderConfigStore } from '../../../core/interfaces/i-provider-config-store.js';
 import type { IProviderKeychainStore } from '../../../core/interfaces/i-provider-keychain-store.js';
+import type { IProviderModelFetcher } from '../../../core/interfaces/i-provider-model-fetcher.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
 export interface ModelHandlerDeps {
+    getModelFetcher?: (providerId: string) => Promise<IProviderModelFetcher | undefined>;
     providerConfigStore: IProviderConfigStore;
     providerKeychainStore: IProviderKeychainStore;
     transport: ITransportServer;
@@ -11,6 +13,7 @@ export interface ModelHandlerDeps {
  * Business logic for model listing and selection — no terminal/UI calls.
  */
 export declare class ModelHandler {
+    private readonly getModelFetcher;
     private readonly providerConfigStore;
     private readonly providerKeychainStore;
     private readonly transport;

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

@@ -1,15 +1,17 @@
 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';
+import { getModelFetcher as getModelFetcherDefault } from '../../http/provider-model-fetcher-registry.js';
 /**
  * Handles model:* events.
  * Business logic for model listing and selection — no terminal/UI calls.
  */
 export class ModelHandler {
+    getModelFetcher;
     providerConfigStore;
     providerKeychainStore;
     transport;
     constructor(deps) {
+        this.getModelFetcher = deps.getModelFetcher ?? getModelFetcherDefault;
         this.providerConfigStore = deps.providerConfigStore;
         this.providerKeychainStore = deps.providerKeychainStore;
         this.transport = deps.transport;
@@ -22,18 +24,21 @@ export class ModelHandler {
     setupList() {
         this.transport.onRequest(ModelEvents.LIST, async (data) => {
             const { providerId } = data;
-            const fetcher = await getModelFetcher(providerId);
+            const fetcher = await this.getModelFetcher(providerId);
             if (!fetcher) {
                 return { favorites: [], models: [], recent: [] };
             }
             // Fetch models from provider API using the correct per-provider fetcher
             let fetchedModels;
             try {
+                const config = await this.providerConfigStore.read();
+                const authMethod = config.providers[providerId]?.authMethod;
                 const apiKey = await this.providerKeychainStore.getApiKey(providerId);
-                fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+                fetchedModels = await fetcher.fetchModels(apiKey ?? '', { authMethod });
             }
-            catch {
-                return { favorites: [], models: [], recent: [] };
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Failed to load models';
+                return { error: message, favorites: [], models: [], recent: [] };
             }
             const models = fetchedModels.map((m) => ({
                 contextLength: m.contextLength,
@@ -61,12 +66,14 @@ export class ModelHandler {
     setupListByProviders() {
         this.transport.onRequest(ModelEvents.LIST_BY_PROVIDERS, async (data) => {
             const { providerIds } = data;
+            const config = await this.providerConfigStore.read();
             const results = await Promise.allSettled(providerIds.map(async (providerId) => {
-                const fetcher = await getModelFetcher(providerId);
+                const fetcher = await this.getModelFetcher(providerId);
                 if (!fetcher)
                     return [];
+                const authMethod = config.providers[providerId]?.authMethod;
                 const apiKey = await this.providerKeychainStore.getApiKey(providerId);
-                const fetchedModels = await fetcher.fetchModels(apiKey ?? '');
+                const fetchedModels = await fetcher.fetchModels(apiKey ?? '', { authMethod });
                 return fetchedModels.map((model) => ({
                     contextLength: model.contextLength,
                     description: model.description,
@@ -98,10 +105,45 @@ export class ModelHandler {
     }
     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 };
+            try {
+                const config = await this.providerConfigStore.read();
+                const providerConfig = config.providers[data.providerId];
+                if (!providerConfig) {
+                    return {
+                        error: `Provider "${data.providerId}" is not connected`,
+                        success: false,
+                    };
+                }
+                let matchedModel;
+                // Validate model against allowed list for OAuth providers
+                if (providerConfig.authMethod === 'oauth') {
+                    const fetcher = await this.getModelFetcher(data.providerId);
+                    if (!fetcher) {
+                        return {
+                            error: `Cannot validate model for OAuth-connected ${data.providerId}: model fetcher unavailable`,
+                            success: false,
+                        };
+                    }
+                    const allowedModels = await fetcher.fetchModels('', { authMethod: 'oauth' });
+                    matchedModel = allowedModels.find((m) => m.id === data.modelId);
+                    if (!matchedModel) {
+                        const allowedIds = allowedModels.map((m) => m.id).join(', ');
+                        return {
+                            error: `Model "${data.modelId}" is not available for OAuth-connected ${data.providerId}. Allowed models: ${allowedIds}`,
+                            success: false,
+                        };
+                    }
+                }
+                const contextLength = data.contextLength ?? matchedModel?.contextLength;
+                await this.providerConfigStore.setActiveProvider(data.providerId);
+                await this.providerConfigStore.setActiveModel(data.providerId, data.modelId, contextLength);
+                this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
+                return { success: true };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Failed to set active model';
+                return { error: message, success: false };
+            }
         });
     }
 }

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

@@ -1,9 +1,24 @@
 import type { IProviderConfigStore } from '../../../core/interfaces/i-provider-config-store.js';
 import type { IProviderKeychainStore } from '../../../core/interfaces/i-provider-keychain-store.js';
+import type { IProviderOAuthTokenStore } from '../../../core/interfaces/i-provider-oauth-token-store.js';
+import type { IBrowserLauncher } from '../../../core/interfaces/services/i-browser-launcher.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import type { PkceParameters, ProviderTokenResponse, TokenExchangeParams } from '../../provider-oauth/index.js';
+import { ProviderCallbackServer } from '../../provider-oauth/index.js';
 export interface ProviderHandlerDeps {
+    browserLauncher: IBrowserLauncher;
+    /** Factory for creating callback servers (injectable for testing) */
+    createCallbackServer?: (options: {
+        callbackPath?: string;
+        port: number;
+    }) => ProviderCallbackServer;
+    /** Token exchange function (injectable for testing) */
+    exchangeCodeForTokens?: (params: TokenExchangeParams) => Promise<ProviderTokenResponse>;
+    /** PKCE generator function (injectable for testing) */
+    generatePkce?: () => PkceParameters;
     providerConfigStore: IProviderConfigStore;
     providerKeychainStore: IProviderKeychainStore;
+    providerOAuthTokenStore: IProviderOAuthTokenStore;
     transport: ITransportServer;
 }
 /**
@@ -11,15 +26,26 @@ export interface ProviderHandlerDeps {
  * Business logic for provider management — no terminal/UI calls.
  */
 export declare class ProviderHandler {
+    private readonly browserLauncher;
+    private readonly createCallbackServer;
+    private readonly exchangeCodeForTokens;
+    private readonly generatePkce;
+    private readonly oauthFlows;
     private readonly providerConfigStore;
     private readonly providerKeychainStore;
+    private readonly providerOAuthTokenStore;
     private readonly transport;
     constructor(deps: ProviderHandlerDeps);
     setup(): void;
+    private cleanupFlowsForClient;
+    private setupAwaitOAuthCallback;
+    private setupCancelOAuth;
     private setupConnect;
     private setupDisconnect;
     private setupGetActive;
     private setupList;
     private setupSetActive;
+    private setupStartOAuth;
+    private setupSubmitOAuthCode;
     private setupValidateApiKey;
 }