berget 1.1.0 → 1.3.0

package/dist/src/services/chat-service.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,13 +42,10 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatService = void 0;
 const client_1 = require("../client");
-const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../utils/logger");
 /**
  * Service for interacting with the chat API
  * Command group: chat
@@ -47,57 +67,95 @@ class ChatService {
     createCompletion(options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                logger_1.logger.debug('Starting createCompletion method');
+                // Initialize options if undefined
+                const optionsCopy = options ? Object.assign({}, options) : { messages: [] };
+                // Check if messages are defined
+                if (!optionsCopy.messages || !Array.isArray(optionsCopy.messages)) {
+                    logger_1.logger.error('messages is undefined or not an array');
+                    optionsCopy.messages = [];
+                }
+                // Log the options object
+                logger_1.logger.debug('Starting createCompletion with options:');
+                try {
+                    logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, optionsCopy), { apiKey: optionsCopy.apiKey ? '***' : undefined, messages: optionsCopy.messages
+                            ? `${optionsCopy.messages.length} messages`
+                            : '0 messages' }), null, 2));
+                }
+                catch (error) {
+                    logger_1.logger.error('Failed to stringify options:', error);
+                }
                 const headers = {};
-                // Check if debug is enabled
-                const isDebug = process.argv.includes('--debug');
-                if (isDebug) {
-                    console.log(chalk_1.default.yellow('DEBUG: Chat completion options:'));
-                    console.log(chalk_1.default.yellow(JSON.stringify(options, null, 2)));
+                // Check for environment variables first - prioritize this over everything else
+                const envApiKey = process.env.BERGET_API_KEY;
+                if (envApiKey) {
+                    logger_1.logger.debug('Using API key from BERGET_API_KEY environment variable');
+                    optionsCopy.apiKey = envApiKey;
+                    // Skip the default API key logic if we already have a key
+                    return this.executeCompletion(optionsCopy, headers);
                 }
-                // 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 } = options, requestOptions = __rest(options, ["apiKey"]);
-                    if (isDebug) {
-                        console.log(chalk_1.default.yellow('DEBUG: Using provided API key'));
-                        console.log(chalk_1.default.yellow('DEBUG: Request options:'));
-                        console.log(chalk_1.default.yellow(JSON.stringify(requestOptions, null, 2)));
-                    }
-                    const { data, error } = yield this.client.POST('/v1/chat/completions', {
-                        body: requestOptions,
-                        headers
-                    });
-                    if (isDebug) {
-                        console.log(chalk_1.default.yellow('DEBUG: API response:'));
-                        console.log(chalk_1.default.yellow(JSON.stringify({ data, error }, null, 2)));
-                        // Output the complete response data for debugging
-                        console.log(chalk_1.default.yellow('DEBUG: Complete response data:'));
-                        console.log(chalk_1.default.yellow(JSON.stringify(data, null, 2)));
-                    }
-                    if (error)
-                        throw new Error(JSON.stringify(error));
-                    return data;
+                // If API key is already provided, use it directly
+                else if (optionsCopy.apiKey) {
+                    logger_1.logger.debug('Using API key provided in options');
+                    // Skip the default API key logic if we already have a key
+                    return this.executeCompletion(optionsCopy, headers);
                 }
+                // Only try to get the default API key if no API key is provided and no env var is set
                 else {
-                    // Use the default authenticated client
-                    if (isDebug) {
-                        console.log(chalk_1.default.yellow('DEBUG: Using default authentication'));
+                    logger_1.logger.debug('No API key provided, trying to get default');
+                    try {
+                        // Import the DefaultApiKeyManager directly
+                        logger_1.logger.debug('Importing DefaultApiKeyManager');
+                        const DefaultApiKeyManager = (yield Promise.resolve().then(() => __importStar(require('../utils/default-api-key')))).DefaultApiKeyManager;
+                        const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+                        logger_1.logger.debug('Got DefaultApiKeyManager instance');
+                        // Try to get the default API key
+                        logger_1.logger.debug('Calling promptForDefaultApiKey');
+                        const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
+                        const apiKey = (defaultApiKeyData === null || defaultApiKeyData === void 0 ? void 0 : defaultApiKeyData.key) ||
+                            (yield defaultApiKeyManager.promptForDefaultApiKey());
+                        logger_1.logger.debug(`Default API key data exists: ${!!defaultApiKeyData}`);
+                        logger_1.logger.debug(`promptForDefaultApiKey returned: ${apiKey ? 'a key' : 'null'}`);
+                        if (apiKey) {
+                            logger_1.logger.debug('Using API key from default API key manager');
+                            optionsCopy.apiKey = apiKey;
+                        }
+                        else {
+                            logger_1.logger.warn('No API key available. You need to either:');
+                            logger_1.logger.warn('1. Create an API key with: berget api-keys create --name "My Key"');
+                            logger_1.logger.warn('2. Set a default API key with: berget api-keys set-default <id>');
+                            logger_1.logger.warn('3. Provide an API key with the --api-key option');
+                            logger_1.logger.warn('4. Set the BERGET_API_KEY environment variable');
+                            logger_1.logger.warn('\nExample:');
+                            logger_1.logger.warn('  export BERGET_API_KEY=your_api_key_here');
+                            logger_1.logger.warn('  # or for a single command:');
+                            logger_1.logger.warn('  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
+                        logger_1.logger.debug('Setting API key in options');
+                        // Only set the API key if it's not null
+                        if (apiKey) {
+                            optionsCopy.apiKey = apiKey;
+                        }
                     }
-                    const { data, error } = yield this.client.POST('/v1/chat/completions', {
-                        body: options
-                    });
-                    if (isDebug) {
-                        console.log(chalk_1.default.yellow('DEBUG: API response:'));
-                        console.log(chalk_1.default.yellow(JSON.stringify({ data, error }, null, 2)));
-                        // Output the complete response data for debugging
-                        console.log(chalk_1.default.yellow('DEBUG: Complete response data:'));
-                        console.log(chalk_1.default.yellow(JSON.stringify(data, null, 2)));
+                    catch (error) {
+                        logger_1.logger.error('Error getting API key:');
+                        if (error instanceof Error) {
+                            logger_1.logger.error(error.message);
+                        }
+                        logger_1.logger.warn('Please create an API key with: berget api-keys create --name "My Key"');
+                        throw new Error('Failed to get API key');
                     }
-                    if (error)
-                        throw new Error(JSON.stringify(error));
-                    return data;
                 }
+                // Set default model if not provided
+                if (!optionsCopy.model) {
+                    logger_1.logger.debug('No model specified, using default: google/gemma-3-27b-it');
+                    optionsCopy.model = 'google/gemma-3-27b-it';
+                }
+                logger_1.logger.debug('Chat completion options:');
+                logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, optionsCopy), { apiKey: optionsCopy.apiKey ? '***' : undefined }), null, 2));
+                return this.executeCompletion(optionsCopy, headers);
             }
             catch (error) {
                 // Improved error handling
@@ -115,11 +173,178 @@ class ChatService {
                         errorMessage = `Chat error: ${error.message}`;
                     }
                 }
-                console.error(chalk_1.default.red(errorMessage));
+                logger_1.logger.error(errorMessage);
                 throw new Error(errorMessage);
             }
         });
     }
+    /**
+     * Execute the completion request with the provided options
+     * @param options The completion options
+     * @param headers Additional headers to include
+     * @returns The completion response
+     */
+    executeCompletion(options, headers = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // If an API key is provided, use it for this request
+                if (options.apiKey) {
+                    // API keys should be sent directly, not with Bearer prefix
+                    headers['Authorization'] = options.apiKey;
+                }
+                // Remove apiKey and onChunk from options before sending to API
+                const { apiKey, onChunk } = options, requestOptions = __rest(options, ["apiKey", "onChunk"]);
+                logger_1.logger.debug('Request options:');
+                logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, requestOptions), { messages: requestOptions.messages
+                        ? `${requestOptions.messages.length} messages`
+                        : '0 messages' }), null, 2));
+                // Handle streaming responses differently
+                if (requestOptions.stream && onChunk) {
+                    return yield this.handleStreamingResponse(Object.assign(Object.assign({}, requestOptions), { onChunk }), headers);
+                }
+                else {
+                    // Ensure model is always defined for the API call
+                    const requestBody = Object.assign(Object.assign({}, requestOptions), { model: requestOptions.model || 'google/gemma-3-27b-it' });
+                    // Debug the headers being sent
+                    logger_1.logger.debug('Headers being sent:');
+                    logger_1.logger.debug(JSON.stringify(headers, null, 2));
+                    const response = yield this.client.POST('/v1/chat/completions', {
+                        body: requestBody,
+                        headers,
+                    });
+                    // Check if response has an error property
+                    const responseAny = response;
+                    if (responseAny && responseAny.error)
+                        throw new Error(JSON.stringify(responseAny.error));
+                    logger_1.logger.debug('API response:');
+                    logger_1.logger.debug(JSON.stringify(response, null, 2));
+                    // Output the complete response data for debugging
+                    logger_1.logger.debug('Complete response data:');
+                    logger_1.logger.debug(JSON.stringify(response.data, null, 2));
+                    return response.data;
+                }
+            }
+            catch (requestError) {
+                logger_1.logger.debug(`Request error: ${requestError instanceof Error
+                    ? requestError.message
+                    : String(requestError)}`);
+                throw requestError;
+            }
+        });
+    }
+    /**
+     * Handle the case when no API key is available
+     */
+    handleNoApiKey() {
+        // We've exhausted all options for getting an API key
+        logger_1.logger.warn('No API key available. You need to either:');
+        logger_1.logger.warn('1. Create an API key with: berget api-keys create --name "My Key"');
+        logger_1.logger.warn('2. Set a default API key with: berget api-keys set-default <id>');
+        logger_1.logger.warn('3. Provide an API key with the --api-key option');
+        logger_1.logger.warn('4. Set the BERGET_API_KEY environment variable');
+        logger_1.logger.warn('\nExample:');
+        logger_1.logger.warn('  export BERGET_API_KEY=your_api_key_here');
+        logger_1.logger.warn('  # or for a single command:');
+        logger_1.logger.warn('  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.');
+    }
+    /**
+     * Handle streaming response from the API
+     * @param options Request options
+     * @param headers Request headers
+     * @returns A promise that resolves when the stream is complete
+     */
+    handleStreamingResponse(options, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.logger.debug('Handling streaming response');
+            // Create URL with query parameters
+            const url = new URL(`${client_1.API_BASE_URL}/v1/chat/completions`);
+            // Debug the headers and options
+            logger_1.logger.debug('Streaming headers:');
+            logger_1.logger.debug(JSON.stringify(headers, null, 2));
+            logger_1.logger.debug('Streaming options:');
+            logger_1.logger.debug(JSON.stringify(Object.assign(Object.assign({}, options), { onChunk: options.onChunk ? 'function present' : 'no function' }), null, 2));
+            try {
+                // Make fetch request directly to handle streaming
+                const response = yield fetch(url.toString(), {
+                    method: 'POST',
+                    headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'text/event-stream' }, headers),
+                    body: JSON.stringify(options),
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    logger_1.logger.error(`Stream request failed: ${response.status} ${response.statusText}`);
+                    logger_1.logger.debug(`Error response: ${errorText}`);
+                    throw new Error(`Stream request failed: ${response.status} ${response.statusText}`);
+                }
+                if (!response.body) {
+                    throw new Error('No response body received');
+                }
+                // Process the stream
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let fullContent = '';
+                let fullResponse = null;
+                while (true) {
+                    const { done, value } = yield reader.read();
+                    if (done)
+                        break;
+                    const chunk = decoder.decode(value, { stream: true });
+                    logger_1.logger.debug(`Received chunk: ${chunk.length} bytes`);
+                    // Process the chunk - it may contain multiple SSE events
+                    const lines = chunk.split('\n');
+                    for (const line of lines) {
+                        if (line.startsWith('data:')) {
+                            const jsonData = line.slice(5).trim();
+                            // Skip empty data or [DONE] marker
+                            if (jsonData === '' || jsonData === '[DONE]')
+                                continue;
+                            try {
+                                const parsedData = JSON.parse(jsonData);
+                                // Call the onChunk callback with the parsed data
+                                if (options.onChunk) {
+                                    options.onChunk(parsedData);
+                                }
+                                // Keep track of the full response
+                                if (!fullResponse) {
+                                    fullResponse = parsedData;
+                                }
+                                else if (parsedData.choices &&
+                                    parsedData.choices[0] &&
+                                    parsedData.choices[0].delta) {
+                                    // Accumulate content for the full response
+                                    if (parsedData.choices[0].delta.content) {
+                                        fullContent += parsedData.choices[0].delta.content;
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                logger_1.logger.error(`Error parsing chunk: ${e}`);
+                                logger_1.logger.debug(`Problematic chunk: ${jsonData}`);
+                            }
+                        }
+                    }
+                }
+                // Construct the final response object similar to non-streaming response
+                if (fullResponse) {
+                    if (fullContent) {
+                        fullResponse.choices[0].message = {
+                            role: 'assistant',
+                            content: fullContent,
+                        };
+                    }
+                    return fullResponse;
+                }
+                return {
+                    choices: [{ message: { role: 'assistant', content: fullContent } }],
+                };
+            }
+            catch (error) {
+                logger_1.logger.error(`Streaming error: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+        });
+    }
     /**
      * List available models
      * Command: berget chat list
@@ -127,9 +352,12 @@ class ChatService {
     listModels(apiKey) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (apiKey) {
+                // 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 ${apiKey}`
+                        Authorization: effectiveApiKey,
                     };
                     const { data, error } = yield this.client.GET('/v1/models', { headers });
                     if (error)
@@ -151,9 +379,9 @@ class ChatService {
                         // 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))}`;
+                            errorMessage = `Models error: ${typeof parsedError.error === 'string'
+                                ? parsedError.error
+                                : parsedError.error.message || JSON.stringify(parsedError.error)}`;
                         }
                     }
                     catch (e) {
@@ -161,7 +389,7 @@ class ChatService {
                         errorMessage = `Models error: ${error.message}`;
                     }
                 }
-                console.error(chalk_1.default.red(errorMessage));
+                logger_1.logger.error(errorMessage);
                 throw new Error(errorMessage);
             }
         });
@@ -173,5 +401,5 @@ ChatService.COMMAND_GROUP = 'chat';
 // Subcommands for this service
 ChatService.COMMANDS = {
     RUN: 'run',
-    LIST: 'list'
+    LIST: 'list',
 };

package/dist/src/utils/default-api-key.js

@@ -22,6 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,7 +39,9 @@ exports.DefaultApiKeyManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-const chalk_1 = __importDefault(require("chalk"));
+const api_key_service_1 = require("../services/api-key-service");
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("./logger");
 /**
  * Manages the default API key for chat commands
  */
@@ -62,7 +73,7 @@ class DefaultApiKeyManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to load default API key configuration'));
+            logger_1.logger.debug('Failed to load default API key configuration');
             this.defaultApiKey = null;
         }
     }
@@ -84,20 +95,27 @@ class DefaultApiKeyManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to save default API key configuration'));
+            logger_1.logger.debug('Failed to save default API key configuration');
         }
     }
     /**
      * Set the default API key
      */
-    setDefaultApiKey(id, name, prefix) {
-        this.defaultApiKey = { id, name, prefix };
+    setDefaultApiKey(id, name, prefix, key) {
+        this.defaultApiKey = { id, name, prefix, key };
         this.saveConfig();
     }
     /**
-     * Get the default API key
+     * Get the default API key string
      */
     getDefaultApiKey() {
+        var _a;
+        return ((_a = this.defaultApiKey) === null || _a === void 0 ? void 0 : _a.key) || null;
+    }
+    /**
+     * Get the default API key data object
+     */
+    getDefaultApiKeyData() {
         return this.defaultApiKey;
     }
     /**
@@ -107,5 +125,96 @@ class DefaultApiKeyManager {
         this.defaultApiKey = null;
         this.saveConfig();
     }
+    /**
+     * Prompts the user to select a default API key if none is set
+     * @returns The selected API key or null if none was selected
+     */
+    promptForDefaultApiKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.debug('promptForDefaultApiKey called');
+                // If we already have a default API key, return it
+                if (this.defaultApiKey) {
+                    logger_1.logger.debug('Using existing default API key');
+                    return this.defaultApiKey.key;
+                }
+                logger_1.logger.debug('No default API key found, getting ApiKeyService');
+                const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+                // Get all API keys
+                let apiKeys;
+                try {
+                    logger_1.logger.debug('Calling apiKeyService.list()');
+                    apiKeys = yield apiKeyService.list();
+                    logger_1.logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`);
+                    if (!apiKeys || apiKeys.length === 0) {
+                        logger_1.logger.warn('No API keys found. Create one with:');
+                        logger_1.logger.info('  berget api-keys create --name "My Key"');
+                        return null;
+                    }
+                }
+                catch (error) {
+                    // Check if this is an authentication error
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const isAuthError = errorMessage.includes('Unauthorized') ||
+                        errorMessage.includes('Authentication failed') ||
+                        errorMessage.includes('AUTH_FAILED');
+                    if (isAuthError) {
+                        logger_1.logger.warn('Authentication required. Please run `berget auth login` first.');
+                    }
+                    else {
+                        logger_1.logger.error('Error fetching API keys:');
+                        if (error instanceof Error) {
+                            logger_1.logger.error(error.message);
+                            logger_1.logger.debug(`API key list error: ${error.message}`);
+                            logger_1.logger.debug(`Stack: ${error.stack}`);
+                        }
+                    }
+                    return null;
+                }
+                logger_1.logger.info('Select an API key to use as default:');
+                // Display available API keys
+                apiKeys.forEach((key, index) => {
+                    logger_1.logger.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`);
+                });
+                // Create readline interface for user input
+                const rl = readline_1.default.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                // Prompt for selection
+                const selection = yield new Promise((resolve) => {
+                    rl.question('Enter number (or press Enter to cancel): ', (answer) => {
+                        rl.close();
+                        const num = parseInt(answer.trim(), 10);
+                        if (isNaN(num) || num < 1 || num > apiKeys.length) {
+                            resolve(-1); // Invalid selection
+                        }
+                        else {
+                            resolve(num - 1); // Convert to zero-based index
+                        }
+                    });
+                });
+                if (selection === -1) {
+                    logger_1.logger.warn('No API key selected');
+                    return null;
+                }
+                const selectedKey = apiKeys[selection];
+                // Create a new API key with the selected name
+                const newKey = yield apiKeyService.create({
+                    name: `CLI Default (copy of ${selectedKey.name})`,
+                    description: 'Created automatically by the Berget CLI for default use'
+                });
+                // Save the new key as default
+                this.setDefaultApiKey(newKey.id.toString(), newKey.name, newKey.key.substring(0, 8), // Use first 8 chars as prefix
+                newKey.key);
+                logger_1.logger.success(`✓ Default API key set to: ${newKey.name}`);
+                return newKey.key;
+            }
+            catch (error) {
+                logger_1.logger.error('Failed to set default API key:', error);
+                return null;
+            }
+        });
+    }
 }
 exports.DefaultApiKeyManager = DefaultApiKeyManager;

package/dist/src/utils/error-handler.js

@@ -35,11 +35,11 @@ function handleError(message, error) {
         console.error(chalk_1.default.dim(`Details: ${error.message}`));
     }
     // Check for authentication errors
-    if ((typeof error === 'string' && error.includes('Unauthorized')) ||
-        (error && error.message && error.message.includes('Unauthorized')) ||
-        (error && error.code && error.code === 401)) {
+    if ((typeof error === 'string' && (error.includes('Unauthorized') || error.includes('Authentication failed'))) ||
+        (error && error.message && (error.message.includes('Unauthorized') || error.message.includes('Authentication failed'))) ||
+        (error && error.code && (error.code === 401 || error.code === 'AUTH_FAILED'))) {
         console.error(chalk_1.default.yellow('\nYou need to be logged in to use this command.'));
-        console.error(chalk_1.default.yellow('Run `berget login` to authenticate.'));
+        console.error(chalk_1.default.yellow('Run `berget auth login` to authenticate.'));
     }
 }
 exports.handleError = handleError;