berget 1.0.0 → 1.1.0

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,177 @@
+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 {
+      const headers: Record<string, string> = {}
+      
+      // Check if debug is enabled
+      const isDebug = process.argv.includes('--debug')
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Chat completion options:'))
+        console.log(chalk.yellow(JSON.stringify(options, null, 2)))
+      }
+      
+      // If an API key is provided, use it for this request
+      if (options.apiKey) {
+        headers['Authorization'] = `Bearer ${options.apiKey}`
+        // Remove apiKey from options before sending to API
+        const { apiKey, ...requestOptions } = options
+        
+        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)))
+        }
+        
+        const { data, error } = await this.client.POST('/v1/chat/completions', {
+          body: requestOptions,
+          headers
+        })
+        
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: API response:'))
+          console.log(chalk.yellow(JSON.stringify({ data, error }, null, 2)))
+          
+          // Output the complete response data for debugging
+          console.log(chalk.yellow('DEBUG: Complete response data:'))
+          console.log(chalk.yellow(JSON.stringify(data, null, 2)))
+        }
+        
+        if (error) throw new Error(JSON.stringify(error))
+        return data
+      } else {
+        // Use the default authenticated client
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Using default authentication'))
+        }
+        
+        const { data, error } = await this.client.POST('/v1/chat/completions', {
+          body: options
+        })
+        
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: API response:'))
+          console.log(chalk.yellow(JSON.stringify({ data, error }, null, 2)))
+          
+          // Output the complete response data for debugging
+          console.log(chalk.yellow('DEBUG: Complete response data:'))
+          console.log(chalk.yellow(JSON.stringify(data, null, 2)))
+        }
+        
+        if (error) throw new Error(JSON.stringify(error))
+        return data
+      }
+    } 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 {
+      if (apiKey) {
+        const headers = {
+          'Authorization': `Bearer ${apiKey}`
+        }
+        
+        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);
+    }
+  }
+  
+}