berget 0.1.0 → 1.1.0

package/src/constants/command-structure.ts

@@ -0,0 +1,184 @@
+/**
+ * Command structure constants for the CLI
+ * Following patterns from AWS CLI and Google Cloud CLI
+ */
+
+// Main command groups
+export const COMMAND_GROUPS = {
+  AUTH: 'auth',
+  API_KEYS: 'api-keys',
+  CLUSTERS: 'clusters',
+  APPS: 'apps',
+  MODELS: 'models',
+  HELM: 'helm',
+  KUBECTL: 'kubectl',
+  FLUX: 'flux',
+  USERS: 'users',
+  BILLING: 'billing',
+  CHAT: 'chat',
+}
+
+// Subcommands for each group
+export const SUBCOMMANDS = {
+  // Auth commands
+  AUTH: {
+    LOGIN: 'login',
+    LOGOUT: 'logout',
+    WHOAMI: 'whoami',
+  },
+  
+  // Chat commands
+  CHAT: {
+    RUN: 'run',
+    LIST: 'list',
+  },
+  
+  // API Keys commands
+  API_KEYS: {
+    LIST: 'list',
+    CREATE: 'create',
+    DELETE: 'delete',
+    ROTATE: 'rotate',
+    DESCRIBE: 'describe',
+    SET_DEFAULT: 'set-default',
+    GET_DEFAULT: 'get-default',
+  },
+  
+  // Clusters commands
+  CLUSTERS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+    GET_USAGE: 'get-usage',
+  },
+  
+  // Apps commands
+  APPS: {
+    LIST_TEMPLATES: 'list-templates',
+    DESCRIBE_TEMPLATE: 'describe-template',
+    LIST_INSTALLATIONS: 'list-installations',
+    INSTALL: 'install',
+    UNINSTALL: 'uninstall',
+    DESCRIBE_INSTALLATION: 'describe-installation',
+  },
+  
+  // Models commands
+  MODELS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+  },
+  
+  // Helm commands
+  HELM: {
+    ADD_REPO: 'add-repo',
+    INSTALL: 'install',
+  },
+  
+  // Kubectl commands
+  KUBECTL: {
+    CREATE_NAMESPACE: 'create-namespace',
+    APPLY: 'apply',
+    GET: 'get',
+  },
+  
+  // Flux commands
+  FLUX: {
+    INSTALL: 'install',
+    BOOTSTRAP: 'bootstrap',
+  },
+  
+  // Users commands
+  USERS: {
+    LIST: 'list',
+    DESCRIBE: 'describe',
+    UPDATE: 'update',
+    INVITE: 'invite',
+  },
+  
+  // Billing commands
+  BILLING: {
+    GET_USAGE: 'get-usage',
+    LIST_INVOICES: 'list-invoices',
+    DESCRIBE_INVOICE: 'describe-invoice',
+    LIST_PAYMENT_METHODS: 'list-payment-methods',
+    ADD_PAYMENT_METHOD: 'add-payment-method',
+    REMOVE_PAYMENT_METHOD: 'remove-payment-method',
+    UPDATE_SUBSCRIPTION: 'update-subscription',
+  },
+}
+
+// Command descriptions
+export const COMMAND_DESCRIPTIONS = {
+  // Auth group
+  [COMMAND_GROUPS.AUTH]: 'Manage authentication and authorization',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.LOGIN}`]: 'Log in to Berget AI',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.LOGOUT}`]: 'Log out from Berget AI',
+  [`${COMMAND_GROUPS.AUTH} ${SUBCOMMANDS.AUTH.WHOAMI}`]: 'Display current user information',
+  
+  // API Keys group
+  [COMMAND_GROUPS.API_KEYS]: 'Manage API keys',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.LIST}`]: 'List all API keys',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.CREATE}`]: 'Create a new API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DELETE}`]: 'Delete an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.ROTATE}`]: 'Rotate an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.DESCRIBE}`]: 'Get usage statistics for an API key',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.SET_DEFAULT}`]: 'Set an API key as the default for chat commands',
+  [`${COMMAND_GROUPS.API_KEYS} ${SUBCOMMANDS.API_KEYS.GET_DEFAULT}`]: 'Show the current default API key',
+  
+  // Clusters group
+  [COMMAND_GROUPS.CLUSTERS]: 'Manage Kubernetes clusters',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.LIST}`]: 'List all clusters',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.DESCRIBE}`]: 'Get detailed information about a cluster',
+  [`${COMMAND_GROUPS.CLUSTERS} ${SUBCOMMANDS.CLUSTERS.GET_USAGE}`]: 'Get resource usage for a cluster',
+  
+  // Apps group
+  [COMMAND_GROUPS.APPS]: 'Manage applications',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.LIST_TEMPLATES}`]: 'List available application templates',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.DESCRIBE_TEMPLATE}`]: 'Get detailed information about an application template',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.LIST_INSTALLATIONS}`]: 'List installed applications',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.INSTALL}`]: 'Install an application',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.UNINSTALL}`]: 'Uninstall an application',
+  [`${COMMAND_GROUPS.APPS} ${SUBCOMMANDS.APPS.DESCRIBE_INSTALLATION}`]: 'Get detailed information about an installed application',
+  
+  // Models group
+  [COMMAND_GROUPS.MODELS]: 'Manage AI models',
+  [`${COMMAND_GROUPS.MODELS} ${SUBCOMMANDS.MODELS.LIST}`]: 'List available AI models',
+  [`${COMMAND_GROUPS.MODELS} ${SUBCOMMANDS.MODELS.DESCRIBE}`]: 'Get detailed information about an AI model',
+  
+  // Helm group
+  [COMMAND_GROUPS.HELM]: 'Manage Helm charts',
+  [`${COMMAND_GROUPS.HELM} ${SUBCOMMANDS.HELM.ADD_REPO}`]: 'Add a Helm repository',
+  [`${COMMAND_GROUPS.HELM} ${SUBCOMMANDS.HELM.INSTALL}`]: 'Install a Helm chart',
+  
+  // Kubectl group
+  [COMMAND_GROUPS.KUBECTL]: 'Manage Kubernetes resources',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.CREATE_NAMESPACE}`]: 'Create a Kubernetes namespace',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.APPLY}`]: 'Apply a Kubernetes configuration',
+  [`${COMMAND_GROUPS.KUBECTL} ${SUBCOMMANDS.KUBECTL.GET}`]: 'Get Kubernetes resources',
+  
+  // Flux group
+  [COMMAND_GROUPS.FLUX]: 'Manage Flux CD',
+  [`${COMMAND_GROUPS.FLUX} ${SUBCOMMANDS.FLUX.INSTALL}`]: 'Install Flux CD',
+  [`${COMMAND_GROUPS.FLUX} ${SUBCOMMANDS.FLUX.BOOTSTRAP}`]: 'Bootstrap Flux CD',
+  
+  // Users group
+  [COMMAND_GROUPS.USERS]: 'Manage users',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.LIST}`]: 'List all users in your organization',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.DESCRIBE}`]: 'Get detailed information about a user',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.UPDATE}`]: 'Update user information',
+  [`${COMMAND_GROUPS.USERS} ${SUBCOMMANDS.USERS.INVITE}`]: 'Invite a new user to your organization',
+  
+  // Billing group
+  [COMMAND_GROUPS.BILLING]: 'Manage billing and usage',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.GET_USAGE}`]: 'Get current usage metrics',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.LIST_INVOICES}`]: 'List all invoices',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.DESCRIBE_INVOICE}`]: 'Get detailed information about an invoice',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.LIST_PAYMENT_METHODS}`]: 'List all payment methods',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.ADD_PAYMENT_METHOD}`]: 'Add a new payment method',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.REMOVE_PAYMENT_METHOD}`]: 'Remove a payment method',
+  [`${COMMAND_GROUPS.BILLING} ${SUBCOMMANDS.BILLING.UPDATE_SUBSCRIPTION}`]: 'Update subscription plan',
+  
+  // Chat group
+  [COMMAND_GROUPS.CHAT]: 'Interact with AI chat models',
+  [`${COMMAND_GROUPS.CHAT} ${SUBCOMMANDS.CHAT.RUN}`]: 'Run a chat session with a specified model',
+  [`${COMMAND_GROUPS.CHAT} ${SUBCOMMANDS.CHAT.LIST}`]: 'List available chat models',
+}

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

@@ -1,5 +1,6 @@
 import { createAuthenticatedClient } from '../client'
 import { handleError } from '../utils/error-handler'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface ApiKey {
   id: number
@@ -25,9 +26,19 @@ export interface ApiKeyResponse {
   created: string
 }
 
+/**
+ * Service for managing API keys
+ * Command group: api-keys
+ */
 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
 
   private constructor() {}
 
@@ -38,7 +49,11 @@ export class ApiKeyService {
     return ApiKeyService.instance
   }
 
-  public async listApiKeys(): Promise<ApiKey[]> {
+  /**
+   * List all API keys
+   * Command: berget api-keys list
+   */
+  public async list(): Promise<ApiKey[]> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys')
       if (error) {
@@ -60,7 +75,11 @@ export class ApiKeyService {
     }
   }
 
-  public async createApiKey(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
+  /**
+   * Create a new API key
+   * Command: berget api-keys create
+   */
+  public async create(options: CreateApiKeyOptions): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.POST('/v1/api-keys', {
         body: options
@@ -73,7 +92,11 @@ export class ApiKeyService {
     }
   }
 
-  public async deleteApiKey(id: string): Promise<boolean> {
+  /**
+   * Delete an API key
+   * Command: berget api-keys delete
+   */
+  public async delete(id: string): Promise<boolean> {
     try {
       const { error } = await this.client.DELETE('/v1/api-keys/{id}', {
         params: { path: { id } }
@@ -86,7 +109,11 @@ export class ApiKeyService {
     }
   }
 
-  public async rotateApiKey(id: string): Promise<ApiKeyResponse> {
+  /**
+   * Rotate an API key
+   * Command: berget api-keys rotate
+   */
+  public async rotate(id: string): Promise<ApiKeyResponse> {
     try {
       const { data, error } = await this.client.PUT('/v1/api-keys/{id}/rotate', {
         params: { path: { id } }
@@ -99,7 +126,11 @@ export class ApiKeyService {
     }
   }
 
-  public async getApiKeyUsage(id: string): Promise<any> {
+  /**
+   * Get usage statistics for an API key
+   * Command: berget api-keys describe
+   */
+  public async describe(id: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET('/v1/api-keys/{id}/usage', {
         params: { path: { id } }

package/src/services/auth-service.ts

@@ -4,14 +4,25 @@ import {
   clearAuthToken,
   apiClient,
 } from '../client'
-import open from 'open'
+// We'll use dynamic import for 'open' to support ESM modules in CommonJS
 import chalk from 'chalk'
 import { handleError } from '../utils/error-handler'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
+/**
+ * Service for authentication operations
+ * Command group: auth
+ */
 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
+
   private constructor() {}
 
   public static getInstance(): AuthService {
@@ -21,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
@@ -42,25 +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) {
-          await open(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(typedDeviceData.verification_url)
           console.log(
             chalk.dim(
               "Browser opened automatically. If it didn't open, please use the URL above."
@@ -80,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
@@ -98,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',
           {
@@ -157,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
+          }
         }
       }
 
@@ -182,25 +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
-    }
-  }
-
-  public async getUserProfile() {
-    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);
+    }
+  }
+  
+}