berget 1.1.0 → 1.3.0

package/dist/src/utils/logger.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Log levels in order of increasing verbosity
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = 0] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Logger class for centralized logging with configurable log levels
+ */
+class Logger {
+    constructor() {
+        this.logLevel = LogLevel.INFO; // Default log level
+        // Set log level from environment variable or command line argument
+        if (process.env.LOG_LEVEL) {
+            this.setLogLevelFromString(process.env.LOG_LEVEL);
+        }
+        else if (process.argv.includes('--debug')) {
+            this.logLevel = LogLevel.DEBUG;
+        }
+        else if (process.argv.includes('--quiet')) {
+            this.logLevel = LogLevel.ERROR;
+        }
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    /**
+     * Set the log level from a string
+     */
+    setLogLevelFromString(level) {
+        switch (level.toLowerCase()) {
+            case 'none':
+                this.logLevel = LogLevel.NONE;
+                break;
+            case 'error':
+                this.logLevel = LogLevel.ERROR;
+                break;
+            case 'warn':
+                this.logLevel = LogLevel.WARN;
+                break;
+            case 'info':
+                this.logLevel = LogLevel.INFO;
+                break;
+            case 'debug':
+                this.logLevel = LogLevel.DEBUG;
+                break;
+            default:
+                // Invalid log level, keep default
+                console.warn(`Invalid log level: ${level}. Using default (INFO).`);
+        }
+    }
+    /**
+     * Set the log level
+     */
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    /**
+     * Get the current log level
+     */
+    getLogLevel() {
+        return this.logLevel;
+    }
+    /**
+     * Log a debug message (only shown at DEBUG level)
+     */
+    debug(message, ...args) {
+        if (this.logLevel >= LogLevel.DEBUG) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.yellow(`DEBUG: ${message}`), ...args);
+            }
+            else {
+                console.log(chalk_1.default.yellow(`DEBUG: ${message}`));
+            }
+        }
+    }
+    /**
+     * Log an info message (shown at INFO level and above)
+     */
+    info(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.blue(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.blue(message));
+            }
+        }
+    }
+    /**
+     * Log a warning message (shown at WARN level and above)
+     */
+    warn(message, ...args) {
+        if (this.logLevel >= LogLevel.WARN) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.yellow(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.yellow(message));
+            }
+        }
+    }
+    /**
+     * Log an error message (shown at ERROR level and above)
+     */
+    error(message, ...args) {
+        if (this.logLevel >= LogLevel.ERROR) {
+            if (args.length > 0) {
+                console.error(chalk_1.default.red(message), ...args);
+            }
+            else {
+                console.error(chalk_1.default.red(message));
+            }
+        }
+    }
+    /**
+     * Log a success message (shown at INFO level and above)
+     */
+    success(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(chalk_1.default.green(message), ...args);
+            }
+            else {
+                console.log(chalk_1.default.green(message));
+            }
+        }
+    }
+    /**
+     * Log a plain message without color (shown at INFO level and above)
+     */
+    log(message, ...args) {
+        if (this.logLevel >= LogLevel.INFO) {
+            if (args.length > 0) {
+                console.log(message, ...args);
+            }
+            else {
+                console.log(message);
+            }
+        }
+    }
+}
+exports.Logger = Logger;
+// Export a singleton instance for easy import
+exports.logger = Logger.getInstance();

package/dist/src/utils/token-manager.js

@@ -22,15 +22,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
 /**
  * Manages authentication tokens including refresh functionality
  */
@@ -62,7 +59,7 @@ class TokenManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to load authentication token'));
+            logger_1.logger.error('Failed to load authentication token');
             this.tokenData = null;
         }
     }
@@ -84,7 +81,7 @@ class TokenManager {
             }
         }
         catch (error) {
-            console.error(chalk_1.default.dim('Failed to save authentication token'));
+            logger_1.logger.error('Failed to save authentication token');
         }
     }
     /**
@@ -117,14 +114,14 @@ class TokenManager {
             // Using a larger buffer to be more proactive about refreshing
             const expirationBuffer = 10 * 60 * 1000; // 10 minutes in milliseconds
             const isExpired = Date.now() + expirationBuffer >= this.tokenData.expires_at;
-            if (isExpired && process.argv.includes('--debug')) {
-                console.log(chalk_1.default.yellow(`DEBUG: Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`));
+            if (isExpired) {
+                logger_1.logger.debug(`Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`);
             }
             return isExpired;
         }
         catch (error) {
             // If there's any error checking expiration, assume token is expired
-            console.error(chalk_1.default.dim(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`));
+            logger_1.logger.error(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         }
     }

package/index.ts

@@ -3,6 +3,8 @@
 import { program } from 'commander'
 import { registerCommands } from './src/commands'
 import { checkBergetConfig } from './src/utils/config-checker'
+import chalk from 'chalk'
+import { version } from './package.json'
 
 // Set version and description
 program
@@ -17,7 +19,7 @@ program
                  __/ |                      
                 |___/   AI on European terms`
   )
-  .version(process.env.npm_package_version || '0.0.1', '-v, --version')
+  .version(version, '-v, --version')
   .option('--local', 'Use local API endpoint (hidden)', false)
   .option('--debug', 'Enable debug output', false)
 
@@ -27,6 +29,55 @@ registerCommands(program)
 // Check for .bergetconfig if not running a command
 if (process.argv.length <= 2) {
   checkBergetConfig()
+  
+  // Show helpful welcome message
+  console.log(chalk.blue('\nWelcome to the Berget CLI!'));
+  console.log(chalk.blue('Common commands:'));
+  console.log(chalk.blue(`  ${chalk.bold('berget auth login')}      - Log in to Berget`));
+  console.log(chalk.blue(`  ${chalk.bold('berget models list')}     - List available AI models`));
+  console.log(chalk.blue(`  ${chalk.bold('berget chat run')}        - Start a chat session`));
+  console.log(chalk.blue(`  ${chalk.bold('berget api-keys list')}   - List your API keys`));
+  console.log(chalk.blue(`\nRun ${chalk.bold('berget --help')} for a complete list of commands.`));
 }
 
+// Add helpful suggestions for common command mistakes
+const commonMistakes: Record<string, string> = {
+  'login': 'auth login',
+  'logout': 'auth logout',
+  'whoami': 'auth whoami',
+  'list-models': 'models list',
+  'list-keys': 'api-keys list',
+  'create-key': 'api-keys create',
+  'list-clusters': 'clusters list',
+  'usage': 'billing usage'
+};
+
+// Add error handler for unknown commands
+program.on('command:*', (operands) => {
+  const unknownCommand = operands[0] as string;
+  console.error(chalk.red(`Error: unknown command '${unknownCommand}'`));
+  
+  // Check if this is a known mistake and suggest the correct command
+  if (unknownCommand in commonMistakes) {
+    console.log(chalk.yellow(`Did you mean? ${chalk.bold(`berget ${commonMistakes[unknownCommand]}`)}`));
+  } else {
+    // Try to find similar commands
+    const availableCommands = program.commands.map(cmd => cmd.name());
+    const similarCommands = availableCommands.filter(cmd => 
+      cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
+    );
+    
+    if (similarCommands.length > 0) {
+      console.log(chalk.yellow('Similar commands:'));
+      similarCommands.forEach(cmd => {
+        console.log(chalk.yellow(`  ${chalk.bold(`berget ${cmd}`)}`));
+      });
+    }
+    
+    console.log(chalk.blue('\nRun `berget --help` for a list of available commands.'));
+  }
+  
+  process.exit(1);
+});
+
 program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"
@@ -29,6 +29,7 @@
     "fs-extra": "^11.3.0",
     "open": "^9.1.0",
     "openapi-fetch": "^0.9.1",
-    "openapi-typescript": "^6.7.4"
+    "openapi-typescript": "^6.7.4",
+    "readline": "^1.3.0"
   }
 }

package/src/client.ts

@@ -5,16 +5,17 @@ import * as path from 'path'
 import * as os from 'os'
 import chalk from 'chalk'
 import { TokenManager } from './utils/token-manager'
+import { logger } from './utils/logger'
 
 // API Base URL
 // Use --local flag to test against local API
 const isLocalMode = process.argv.includes('--local')
-const API_BASE_URL =
+export const API_BASE_URL =
   process.env.BERGET_API_URL ||
   (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai')
 
-if (isLocalMode && !process.env.BERGET_API_URL && process.argv.includes('--debug')) {
-  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'))
+if (isLocalMode && !process.env.BERGET_API_URL) {
+  logger.debug('Using local API endpoint: http://localhost:3000')
 }
 
 // Create a typed client for the Berget API
@@ -50,11 +51,9 @@ export const clearAuthToken = (): void => {
 export const createAuthenticatedClient = () => {
   const tokenManager = TokenManager.getInstance()
 
-  if (!tokenManager.getAccessToken() && process.argv.includes('--debug')) {
-    console.warn(
-      chalk.yellow(
-        'No authentication token found. Please run `berget auth login` first.'
-      )
+  if (!tokenManager.getAccessToken()) {
+    logger.debug(
+      'No authentication token found. Please run `berget auth login` first.'
     )
   }
 
@@ -88,7 +87,10 @@ export const createAuthenticatedClient = () => {
           }
 
           // Update the Authorization header with the current token
-          if (tokenManager.getAccessToken()) {
+          if (
+            !args[1]?.headers?.Authorization &&
+            tokenManager.getAccessToken()
+          ) {
             if (!args[1]) args[1] = {}
             if (!args[1].headers) args[1].headers = {}
             args[1].headers.Authorization = `Bearer ${tokenManager.getAccessToken()}`
@@ -101,17 +103,13 @@ export const createAuthenticatedClient = () => {
               ...args
             )
           } catch (requestError) {
-            if (process.argv.includes('--debug')) {
-              console.log(
-                chalk.red(
-                  `DEBUG: Request error: ${
-                    requestError instanceof Error
-                      ? requestError.message
-                      : String(requestError)
-                  }`
-                )
-              )
-            }
+            logger.debug(
+              `Request error: ${
+                requestError instanceof Error
+                  ? requestError.message
+                  : String(requestError)
+              }`
+            )
             return {
               error: {
                 message: `Request failed: ${
@@ -126,49 +124,59 @@ export const createAuthenticatedClient = () => {
           // If we get an auth error, try to refresh the token and retry
           if (result.error) {
             // Detect various forms of authentication errors
-            const isAuthError =
+            let isAuthError = false
+
+            try {
               // Standard 401 Unauthorized
-              (typeof result.error === 'object' && result.error.status === 401) ||
+              if (
+                typeof result.error === 'object' &&
+                result.error.status === 401
+              ) {
+                isAuthError = true
+              }
               // OAuth specific errors
-              (result.error.error &&
+              else if (
+                result.error.error &&
                 (result.error.error.code === 'invalid_token' ||
-                 result.error.error.code === 'token_expired' ||
-                 result.error.error.message === 'Invalid API key' ||
-                 result.error.error.message?.toLowerCase().includes('token') ||
-                 result.error.error.message?.toLowerCase().includes('unauthorized'))) ||
+                  result.error.error.code === 'token_expired' ||
+                  result.error.error.message === 'Invalid API key' ||
+                  result.error.error.message?.toLowerCase().includes('token') ||
+                  result.error.error.message
+                    ?.toLowerCase()
+                    .includes('unauthorized'))
+              ) {
+                isAuthError = true
+              }
               // Message-based detection as fallback
-              (typeof result.error === 'string' && 
+              else if (
+                typeof result.error === 'string' &&
                 (result.error.toLowerCase().includes('unauthorized') ||
-                 result.error.toLowerCase().includes('token') ||
-                 result.error.toLowerCase().includes('auth')))
+                  result.error.toLowerCase().includes('token') ||
+                  result.error.toLowerCase().includes('auth'))
+              ) {
+                isAuthError = true
+              }
+            } catch (parseError) {
+              // If we can't parse the error structure, do a simple string check
+              const errorStr = String(result.error)
+              if (
+                errorStr.toLowerCase().includes('unauthorized') ||
+                errorStr.toLowerCase().includes('token') ||
+                errorStr.toLowerCase().includes('auth')
+              ) {
+                isAuthError = true
+              }
+            }
 
             if (isAuthError && tokenManager.getRefreshToken()) {
-              if (process.argv.includes('--debug')) {
-                console.log(
-                  chalk.yellow(
-                    'DEBUG: Auth error detected, attempting token refresh'
-                  )
-                )
-                console.log(
-                  chalk.yellow(
-                    `DEBUG: Error details: ${JSON.stringify(
-                      result.error,
-                      null,
-                      2
-                    )}`
-                  )
-                )
-              }
+              logger.debug('Auth error detected, attempting token refresh')
+              logger.debug(
+                `Error details: ${JSON.stringify(result.error, null, 2)}`
+              )
 
               const refreshed = await refreshAccessToken(tokenManager)
               if (refreshed) {
-                if (process.argv.includes('--debug')) {
-                  console.log(
-                    chalk.green(
-                      'DEBUG: Token refreshed successfully, retrying request'
-                    )
-                  )
-                }
+                logger.debug('Token refreshed successfully, retrying request')
 
                 // Update the Authorization header with the new token
                 if (!args[1]) args[1] = {}
@@ -180,13 +188,12 @@ export const createAuthenticatedClient = () => {
                   ...args
                 )
               } else {
-                if (process.argv.includes('--debug')) {
-                  console.log(chalk.red('DEBUG: Token refresh failed'))
-                }
-                
+                logger.debug('Token refresh failed')
+
                 // Add a more helpful error message for users
                 if (typeof result.error === 'object') {
-                  result.error.userMessage = 'Your session has expired. Please run `berget auth login` to log in again.'
+                  result.error.userMessage =
+                    'Your session has expired. Please run `berget auth login` to log in again.'
                 }
               }
             }
@@ -210,9 +217,7 @@ async function refreshAccessToken(
     const refreshToken = tokenManager.getRefreshToken()
     if (!refreshToken) return false
 
-    if (process.argv.includes('--debug')) {
-      console.log(chalk.yellow('DEBUG: Attempting to refresh access token'))
-    }
+    logger.debug('Attempting to refresh access token')
 
     // Use fetch directly since this endpoint might not be in the OpenAPI spec
     try {
@@ -223,15 +228,13 @@ async function refreshAccessToken(
           Accept: 'application/json',
         },
         body: JSON.stringify({ refresh_token: refreshToken }),
-      });
+      })
 
       // Handle HTTP errors
       if (!response.ok) {
-        if (process.argv.includes('--debug')) {
-          console.log(
-            chalk.yellow(`DEBUG: Token refresh error: HTTP ${response.status} ${response.statusText}`)
-          )
-        }
+        logger.debug(
+          `Token refresh error: HTTP ${response.status} ${response.statusText}`
+        )
 
         // Check if the refresh token itself is expired or invalid
         if (response.status === 401 || response.status === 403) {
@@ -273,34 +276,33 @@ async function refreshAccessToken(
         return false
       }
 
-      if (process.argv.includes('--debug')) {
-        console.log(chalk.green('DEBUG: Token refreshed successfully'))
-      }
+      logger.debug('Token refreshed successfully')
 
       // Update the token
-      tokenManager.updateAccessToken(
-        data.token,
-        data.expires_in || 3600
-      )
-      
+      tokenManager.updateAccessToken(data.token, data.expires_in || 3600)
+
       // If a new refresh token was provided, update that too
       if (data.refresh_token) {
-        tokenManager.setTokens(data.token, data.refresh_token, data.expires_in || 3600)
-        if (process.argv.includes('--debug')) {
-          console.log(chalk.green('DEBUG: Refresh token also updated'))
-        }
+        tokenManager.setTokens(
+          data.token,
+          data.refresh_token,
+          data.expires_in || 3600
+        )
+        logger.debug('Refresh token also updated')
       }
     } catch (fetchError) {
       console.warn(
         chalk.yellow(
           `Failed to refresh token: ${
-            fetchError instanceof Error ? fetchError.message : String(fetchError)
+            fetchError instanceof Error
+              ? fetchError.message
+              : String(fetchError)
           }`
         )
       )
       return false
     }
-    
+
     return true
   } catch (error) {
     console.warn(

package/src/commands/api-keys.ts

@@ -50,10 +50,15 @@ export function registerApiKeyCommands(program: Command): void {
             ? chalk.green('● Active')
             : chalk.red('● Inactive')
 
+          // Format the prefix to ensure it's not too long
+          const prefixStr = key.prefix.length > 12
+            ? key.prefix.substring(0, 12) + '...'
+            : key.prefix
+
           console.log(
             String(key.id).padEnd(10) +
               key.name.padEnd(25) +
-              key.prefix.padEnd(12) +
+              prefixStr.padEnd(15) +
               status.padEnd(12) +
               key.created.substring(0, 10).padEnd(12) +
               lastUsed
@@ -318,10 +323,15 @@ export function registerApiKeyCommands(program: Command): void {
         
         // Save the default API key
         const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
+        
+        // We need to rotate the key to get the actual key value
+        const rotatedKey = await apiKeyService.rotate(id)
+        
         defaultApiKeyManager.setDefaultApiKey(
           id, 
           selectedKey.name, 
-          selectedKey.prefix
+          selectedKey.prefix,
+          rotatedKey.key
         )
         
         console.log(chalk.green(`✓ API key "${selectedKey.name}" set as default for chat commands`))
@@ -339,9 +349,9 @@ export function registerApiKeyCommands(program: Command): void {
     .action(() => {
       try {
         const defaultApiKeyManager = DefaultApiKeyManager.getInstance()
-        const defaultApiKey = defaultApiKeyManager.getDefaultApiKey()
+        const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData()
         
-        if (!defaultApiKey) {
+        if (!defaultApiKeyData) {
           console.log(chalk.yellow('No default API key set'))
           console.log('')
           console.log('To set a default API key, run:')
@@ -351,9 +361,9 @@ export function registerApiKeyCommands(program: Command): void {
         
         console.log(chalk.bold('Default API key:'))
         console.log('')
-        console.log(`${chalk.dim('ID:')}     ${defaultApiKey.id}`)
-        console.log(`${chalk.dim('Name:')}   ${defaultApiKey.name}`)
-        console.log(`${chalk.dim('Prefix:')} ${defaultApiKey.prefix}`)
+        console.log(`${chalk.dim('ID:')}     ${defaultApiKeyData.id}`)
+        console.log(`${chalk.dim('Name:')}   ${defaultApiKeyData.name}`)
+        console.log(`${chalk.dim('Prefix:')} ${defaultApiKeyData.prefix}`)
         console.log('')
         console.log(chalk.dim('This API key will be used by default when running chat commands'))
         console.log(chalk.dim('You can override it with --api-key or --api-key-id options'))