berget 1.0.0 → 1.2.0

package/src/services/api-key-service.ts

@@ -33,10 +33,10 @@ export interface ApiKeyResponse {
 export class ApiKeyService {
   private static instance: ApiKeyService
   private client = createAuthenticatedClient()
-  
+
   // Command group name for this service
   public static readonly COMMAND_GROUP = COMMAND_GROUPS.API_KEYS
-  
+
   // Subcommands for this service
   public static readonly COMMANDS = SUBCOMMANDS.API_KEYS
 
@@ -56,18 +56,7 @@ export class ApiKeyService {
   public async list(): Promise<ApiKey[]> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys')
-      if (error) {
-        // Check if this is an authentication error
-        const errorObj = typeof error === 'string' ? JSON.parse(error) : error;
-        if (errorObj.status === 401) {
-          throw new Error(JSON.stringify({
-            error: "Authentication failed. Your session may have expired.",
-            code: "AUTH_FAILED",
-            details: "Please run 'berget login' to authenticate again."
-          }))
-        }
-        throw new Error(JSON.stringify(error))
-      }
+      if (error) throw error
       return data || []
     } catch (error) {
       handleError('Failed to list API keys', error)
@@ -82,7 +71,7 @@ export class ApiKeyService {
   public async create(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.POST('/v1/api-keys', {
-        body: options
+        body: options,
       })
       if (error) throw new Error(JSON.stringify(error))
       return data!
@@ -99,7 +88,7 @@ export class ApiKeyService {
   public async delete(id: string): Promise<boolean> {
     try {
       const { error } = await this.client.DELETE('/v1/api-keys/{id}', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return true
@@ -115,9 +104,12 @@ export class ApiKeyService {
    */
   public async rotate(id: string): Promise<ApiKeyResponse> {
     try {
-      const { data, error } = await this.client.PUT('/v1/api-keys/{id}/rotate', {
-        params: { path: { id } }
-      })
+      const { data, error } = await this.client.PUT(
+        '/v1/api-keys/{id}/rotate',
+        {
+          params: { path: { id } },
+        }
+      )
       if (error) throw new Error(JSON.stringify(error))
       return data!
     } catch (error) {
@@ -133,7 +125,7 @@ export class ApiKeyService {
   public async describe(id: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys/{id}/usage', {
-        params: { path: { id } }
+        params: { path: { id } },
       })
       if (error) throw new Error(JSON.stringify(error))
       return data

package/src/services/auth-service.ts

@@ -16,10 +16,10 @@ import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 export class AuthService {
   private static instance: AuthService
   private client = createAuthenticatedClient()
-  
+
   // Command group name for this service
   public static readonly COMMAND_GROUP = COMMAND_GROUPS.AUTH
-  
+
   // Subcommands for this service
   public static readonly COMMANDS = SUBCOMMANDS.AUTH
 
@@ -32,6 +32,21 @@ export class AuthService {
     return AuthService.instance
   }
 
+  public async whoami(): Promise<any> {
+    try {
+      const { data: profile, error } = await this.client.GET('/v1/users/me')
+      if (error) {
+        throw new Error(
+          error ? JSON.stringify(error) : 'Failed to get user profile'
+        )
+      }
+      return profile
+    } catch (error) {
+      handleError('Failed to get user profile', error)
+      return null
+    }
+  }
+
   public async login(): Promise<boolean> {
     try {
       // Clear any existing token to ensure a fresh login
@@ -53,27 +68,40 @@ export class AuthService {
         )
       }
 
+      // Type assertion for deviceData
+      const typedDeviceData = deviceData as {
+        verification_url?: string
+        user_code?: string
+        device_code?: string
+        expires_in?: number
+        interval?: number
+      }
+
       // Display information to user
       console.log(chalk.cyan('\nTo complete login:'))
       console.log(
         chalk.cyan(
           `1. Open this URL: ${chalk.bold(
-            deviceData.verification_url || 'https://auth.berget.ai/device'
+            typedDeviceData.verification_url ||
+              'https://keycloak.berget.ai/device'
           )}`
         )
       )
-      console.log(
-        chalk.cyan(
-          `2. Enter this code: ${chalk.bold(deviceData.user_code || '')}\n`
+      if (!typedDeviceData.verification_url)
+        console.log(
+          chalk.cyan(
+            `2. Enter this code: ${chalk.bold(
+              typedDeviceData.user_code || ''
+            )}\n`
+          )
         )
-      )
 
       // Try to open browser automatically
       try {
-        if (deviceData.verification_url) {
+        if (typedDeviceData.verification_url) {
           // Use dynamic import for the 'open' package
-          const open = await import('open').then(m => m.default);
-          await open(deviceData.verification_url);
+          const open = await import('open').then((m) => m.default)
+          await open(typedDeviceData.verification_url)
           console.log(
             chalk.dim(
               "Browser opened automatically. If it didn't open, please use the URL above."
@@ -93,9 +121,11 @@ export class AuthService {
       // Step 2: Poll for completion
       const startTime = Date.now()
       const expiresIn =
-        deviceData.expires_in !== undefined ? deviceData.expires_in : 900
+        typedDeviceData.expires_in !== undefined
+          ? typedDeviceData.expires_in
+          : 900
       const expiresAt = startTime + expiresIn * 1000
-      let pollInterval = (deviceData.interval || 5) * 1000
+      let pollInterval = (typedDeviceData.interval || 5) * 1000
 
       const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
       let spinnerIdx = 0
@@ -111,7 +141,7 @@ export class AuthService {
         spinnerIdx = (spinnerIdx + 1) % spinner.length
 
         // Check if authentication is complete
-        const deviceCode = deviceData.device_code || ''
+        const deviceCode = typedDeviceData.device_code || ''
         const { data: tokenData, error: tokenError } = await apiClient.POST(
           '/v1/auth/device/token',
           {
@@ -170,21 +200,56 @@ export class AuthService {
             }
             continue
           }
-        } else if (tokenData && tokenData.token) {
-          // Success!
-          saveAuthToken(tokenData.token)
-
-          process.stdout.write('\r' + ' '.repeat(50) + '\r') // Clear the spinner line
-          console.log(chalk.green('✓ Successfully logged in to Berget'))
+        } else if (tokenData) {
+          // Type assertion for tokenData
+          const typedTokenData = tokenData as {
+            token?: string
+            refresh_token?: string
+            expires_in?: number
+            refresh_expires_in?: number
+            user?: {
+              id?: string
+              email?: string
+              name?: string
+            }
+          }
 
-          if (tokenData.user) {
-            const user = tokenData.user as any
-            console.log(
-              chalk.green(`Logged in as ${user.name || user.email || 'User'}`)
+          if (typedTokenData.token) {
+            // Success!
+            saveAuthToken(
+              typedTokenData.token,
+              typedTokenData.refresh_token || '',
+              typedTokenData.expires_in || 3600
             )
-          }
 
-          return true
+            if (process.argv.includes('--debug')) {
+              console.log(chalk.yellow('DEBUG: Token data received:'))
+              console.log(
+                chalk.yellow(
+                  JSON.stringify(
+                    {
+                      expires_in: typedTokenData.expires_in,
+                      refresh_expires_in: typedTokenData.refresh_expires_in,
+                    },
+                    null,
+                    2
+                  )
+                )
+              )
+            }
+
+            process.stdout.write('\r' + ' '.repeat(50) + '\r') // Clear the spinner line
+            console.log(chalk.green('✓ Successfully logged in to Berget'))
+
+            if (typedTokenData.user) {
+              const user = typedTokenData.user
+              console.log(
+                chalk.green(`Logged in as ${user.name || user.email || 'User'}`)
+              )
+            }
+
+            return true
+          }
         }
       }
 
@@ -195,29 +260,4 @@ export class AuthService {
       return false
     }
   }
-
-  public async isAuthenticated(): Promise<boolean> {
-    try {
-      // Call an API endpoint that requires authentication
-      const { data, error } = await this.client.GET('/v1/users/me')
-      return !!data && !error
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Get current user profile
-   * Command: berget auth whoami
-   */
-  public async whoami() {
-    try {
-      const { data, error } = await this.client.GET('/v1/users/me')
-      if (error) throw new Error(JSON.stringify(error))
-      return data
-    } catch (error) {
-      handleError('Failed to get user profile', error)
-      throw error
-    }
-  }
 }

package/src/services/chat-service.ts

@@ -0,0 +1,295 @@
+import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
+import chalk from 'chalk'
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant'
+  content: string
+}
+
+export interface ChatCompletionOptions {
+  model: string
+  messages: ChatMessage[]
+  temperature?: number
+  max_tokens?: number
+  stream?: boolean
+  top_p?: number
+  apiKey?: string
+}
+
+/**
+ * Service for interacting with the chat API
+ * Command group: chat
+ */
+export class ChatService {
+  private static instance: ChatService
+  private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = 'chat'
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = {
+    RUN: 'run',
+    LIST: 'list'
+  }
+
+  private constructor() {}
+
+  public static getInstance(): ChatService {
+    if (!ChatService.instance) {
+      ChatService.instance = new ChatService()
+    }
+    return ChatService.instance
+  }
+
+  /**
+   * Create a chat completion
+   * Command: berget chat completion
+   */
+  public async createCompletion(options: ChatCompletionOptions): Promise<any> {
+    try {
+      console.log(chalk.yellow('DEBUG: Starting createCompletion method'))
+      
+      // Check if options is defined
+      if (!options) {
+        console.log(chalk.red('ERROR: options is undefined'))
+        throw new Error('Chat completion options are undefined')
+      }
+      
+      // Log the raw options object
+      console.log(chalk.yellow('DEBUG: Raw options:'), typeof options, options ? 'defined' : 'undefined')
+      
+      const headers: Record<string, string> = {}
+      
+      // Check if debug is enabled
+      const isDebug = process.argv.includes('--debug')
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Starting createCompletion with options:'))
+        try {
+          console.log(chalk.yellow(JSON.stringify({
+            ...options,
+            apiKey: options.apiKey ? '***' : undefined,
+            messages: options.messages ? `${options.messages.length} messages` : undefined
+          }, null, 2)))
+        } catch (error) {
+          console.log(chalk.red('ERROR: Failed to stringify options:'), error)
+        }
+      }
+      
+      // Create a copy of options to avoid modifying the original
+      const optionsCopy = { ...options }
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Checking for API key'))
+        console.log(chalk.yellow(`DEBUG: optionsCopy.apiKey exists: ${!!optionsCopy.apiKey}`))
+      }
+      
+      // Check for environment variables first - prioritize this over everything else
+      const envApiKey = process.env.BERGET_API_KEY;
+      if (envApiKey) {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Using API key from BERGET_API_KEY environment variable'));
+        }
+        optionsCopy.apiKey = envApiKey;
+      } 
+      // Only try to get the default API key if no API key is provided and no env var is set
+      else if (!optionsCopy.apiKey) {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: No API key provided, trying to get default'))
+        }
+        
+        try {
+          // Import the DefaultApiKeyManager directly
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Importing DefaultApiKeyManager'))
+          }
+          
+          const DefaultApiKeyManager = (await import('../utils/default-api-key')).DefaultApiKeyManager;
+          const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+          
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Got DefaultApiKeyManager instance'))
+          }
+          
+          // Try to get the default API key
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Calling promptForDefaultApiKey'))
+          }
+          
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
+          const apiKey = defaultApiKeyData?.key || await defaultApiKeyManager.promptForDefaultApiKey();
+          
+          if (isDebug) {
+            console.log(chalk.yellow(`DEBUG: Default API key data exists: ${!!defaultApiKeyData}`))
+            console.log(chalk.yellow(`DEBUG: promptForDefaultApiKey returned: ${apiKey ? 'a key' : 'null'}`))
+          }
+          
+          if (apiKey) {
+            if (isDebug) {
+              console.log(chalk.yellow('DEBUG: Using API key from default API key manager'));
+            }
+            optionsCopy.apiKey = apiKey;
+          } else {
+            console.log(chalk.yellow('No API key available. You need to either:'));
+            console.log(chalk.yellow('1. Create an API key with: berget api-keys create --name "My Key"'));
+            console.log(chalk.yellow('2. Set a default API key with: berget api-keys set-default <id>'));
+            console.log(chalk.yellow('3. Provide an API key with the --api-key option'));
+            console.log(chalk.yellow('4. Set the BERGET_API_KEY environment variable'));
+            console.log(chalk.yellow('\nExample:'));
+            console.log(chalk.yellow('  export BERGET_API_KEY=your_api_key_here'));
+            console.log(chalk.yellow('  # or for a single command:'));
+            console.log(chalk.yellow('  BERGET_API_KEY=your_api_key_here berget chat run google/gemma-3-27b-it'));
+            throw new Error('No API key provided and no default API key set');
+          }
+          
+          // Set the API key in the options
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Setting API key in options'))
+          }
+          
+          // Only set the API key if it's not null
+          if (apiKey) {
+            optionsCopy.apiKey = apiKey;
+          }
+        } catch (error) {
+          console.log(chalk.red('Error getting API key:'))
+          if (error instanceof Error) {
+            console.log(chalk.red(error.message))
+          }
+          console.log(chalk.yellow('Please create an API key with: berget api-keys create --name "My Key"'))
+          throw new Error('Failed to get API key')
+        }
+      }
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Chat completion options:'))
+        console.log(chalk.yellow(JSON.stringify({
+          ...optionsCopy,
+          apiKey: optionsCopy.apiKey ? '***' : undefined // Hide the actual API key in debug output
+        }, null, 2)))
+      }
+      
+      // If an API key is provided, use it for this request
+      if (optionsCopy.apiKey) {
+        headers['Authorization'] = `Bearer ${optionsCopy.apiKey}`
+        // Remove apiKey from options before sending to API
+        const { apiKey, ...requestOptions } = optionsCopy
+        
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Using provided API key'))
+          console.log(chalk.yellow('DEBUG: Request options:'))
+          console.log(chalk.yellow(JSON.stringify(requestOptions, null, 2)))
+        }
+        
+        try {
+          const response = await this.client.POST('/v1/chat/completions', {
+            body: requestOptions,
+            headers
+          })
+          
+          // Check if response has an error property
+          const responseAny = response as any;
+          if (responseAny && responseAny.error) 
+            throw new Error(JSON.stringify(responseAny.error))
+          
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: API response:'))
+            console.log(chalk.yellow(JSON.stringify(response, null, 2)))
+            
+            // Output the complete response data for debugging
+            console.log(chalk.yellow('DEBUG: Complete response data:'))
+            console.log(chalk.yellow(JSON.stringify(response.data, null, 2)))
+          }
+          
+          return response.data
+        } catch (requestError) {
+          if (process.argv.includes('--debug')) {
+            console.log(chalk.red(`DEBUG: Request error: ${requestError instanceof Error ? requestError.message : String(requestError)}`))
+          }
+          throw requestError
+        }
+      } else {
+        // We've exhausted all options for getting an API key
+        console.log(chalk.yellow('No API key available. You need to either:'));
+        console.log(chalk.yellow('1. Create an API key with: berget api-keys create --name "My Key"'));
+        console.log(chalk.yellow('2. Set a default API key with: berget api-keys set-default <id>'));
+        console.log(chalk.yellow('3. Provide an API key with the --api-key option'));
+        console.log(chalk.yellow('4. Set the BERGET_API_KEY environment variable'));
+        console.log(chalk.yellow('\nExample:'));
+        console.log(chalk.yellow('  export BERGET_API_KEY=your_api_key_here'));
+        console.log(chalk.yellow('  # or for a single command:'));
+        console.log(chalk.yellow('  BERGET_API_KEY=your_api_key_here berget chat run google/gemma-3-27b-it'));
+        throw new Error('No API key available. Please provide an API key or set a default API key.');
+      }
+    } catch (error) {
+      // Improved error handling
+      let errorMessage = 'Failed to create chat completion';
+      
+      if (error instanceof Error) {
+        try {
+          // Try to parse the error message as JSON
+          const parsedError = JSON.parse(error.message);
+          if (parsedError.error && parsedError.error.message) {
+            errorMessage = `Chat error: ${parsedError.error.message}`;
+          }
+        } catch (e) {
+          // If parsing fails, use the original error message
+          errorMessage = `Chat error: ${error.message}`;
+        }
+      }
+      
+      console.error(chalk.red(errorMessage));
+      throw new Error(errorMessage);
+    }
+  }
+  
+  /**
+   * List available models
+   * Command: berget chat list
+   */
+  public async listModels(apiKey?: string): Promise<any> {
+    try {
+      // Check for environment variable first, then fallback to provided API key
+      const envApiKey = process.env.BERGET_API_KEY;
+      const effectiveApiKey = envApiKey || apiKey;
+      
+      if (effectiveApiKey) {
+        const headers = {
+          'Authorization': `Bearer ${effectiveApiKey}`
+        }
+        
+        const { data, error } = await this.client.GET('/v1/models', { headers })
+        if (error) throw new Error(JSON.stringify(error))
+        return data
+      } else {
+        const { data, error } = await this.client.GET('/v1/models')
+        if (error) throw new Error(JSON.stringify(error))
+        return data
+      }
+    } catch (error) {
+      // Improved error handling
+      let errorMessage = 'Failed to list models';
+      
+      if (error instanceof Error) {
+        try {
+          // Try to parse the error message as JSON
+          const parsedError = JSON.parse(error.message);
+          if (parsedError.error) {
+            errorMessage = `Models error: ${typeof parsedError.error === 'string' ? 
+              parsedError.error : 
+              (parsedError.error.message || JSON.stringify(parsedError.error))}`;
+          }
+        } catch (e) {
+          // If parsing fails, use the original error message
+          errorMessage = `Models error: ${error.message}`;
+        }
+      }
+      
+      console.error(chalk.red(errorMessage));
+      throw new Error(errorMessage);
+    }
+  }
+  
+}