berget 1.0.0 → 1.2.0

package/src/utils/default-api-key.ts

@@ -0,0 +1,229 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import chalk from 'chalk'
+import { ApiKeyService } from '../services/api-key-service'
+import readline from 'readline'
+
+interface DefaultApiKeyData {
+  id: string
+  name: string
+  prefix: string
+  key: string
+}
+
+/**
+ * Manages the default API key for chat commands
+ */
+export class DefaultApiKeyManager {
+  private static instance: DefaultApiKeyManager
+  private configFilePath: string
+  private defaultApiKey: DefaultApiKeyData | null = null
+  
+  private constructor() {
+    // Set up config file path in user's home directory
+    const bergetDir = path.join(os.homedir(), '.berget')
+    if (!fs.existsSync(bergetDir)) {
+      fs.mkdirSync(bergetDir, { recursive: true })
+    }
+    this.configFilePath = path.join(bergetDir, 'default-api-key.json')
+    this.loadConfig()
+  }
+  
+  public static getInstance(): DefaultApiKeyManager {
+    if (!DefaultApiKeyManager.instance) {
+      DefaultApiKeyManager.instance = new DefaultApiKeyManager()
+    }
+    return DefaultApiKeyManager.instance
+  }
+  
+  /**
+   * Load default API key from file
+   */
+  private loadConfig(): void {
+    try {
+      if (fs.existsSync(this.configFilePath)) {
+        const data = fs.readFileSync(this.configFilePath, 'utf8')
+        this.defaultApiKey = JSON.parse(data)
+      }
+    } catch (error) {
+      if (process.argv.includes('--debug')) {
+        console.error(chalk.dim('Failed to load default API key configuration'))
+      }
+      this.defaultApiKey = null
+    }
+  }
+  
+  /**
+   * Save default API key to file
+   */
+  private saveConfig(): void {
+    try {
+      if (this.defaultApiKey) {
+        fs.writeFileSync(this.configFilePath, JSON.stringify(this.defaultApiKey, null, 2))
+        // Set file permissions to be readable only by the owner
+        fs.chmodSync(this.configFilePath, 0o600)
+      } else {
+        // If default API key is null, remove the file
+        if (fs.existsSync(this.configFilePath)) {
+          fs.unlinkSync(this.configFilePath)
+        }
+      }
+    } catch (error) {
+      if (process.argv.includes('--debug')) {
+        console.error(chalk.dim('Failed to save default API key configuration'))
+      }
+    }
+  }
+  
+  /**
+   * Set the default API key
+   */
+  public setDefaultApiKey(id: string, name: string, prefix: string, key: string): void {
+    this.defaultApiKey = { id, name, prefix, key }
+    this.saveConfig()
+  }
+  
+  /**
+   * Get the default API key string
+   */
+  public getDefaultApiKey(): string | null {
+    return this.defaultApiKey?.key || null
+  }
+  
+  /**
+   * Get the default API key data object
+   */
+  public getDefaultApiKeyData(): DefaultApiKeyData | null {
+    return this.defaultApiKey
+  }
+  
+  /**
+   * Clear the default API key
+   */
+  public clearDefaultApiKey(): void {
+    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
+   */
+  public async promptForDefaultApiKey(): Promise<string | null> {
+    try {
+      const isDebug = process.argv.includes('--debug')
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: promptForDefaultApiKey called'))
+      }
+      
+      // If we already have a default API key, return it
+      if (this.defaultApiKey) {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Using existing default API key'))
+        }
+        return this.defaultApiKey.key
+      }
+
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: No default API key found, getting ApiKeyService'))
+      }
+      
+      const apiKeyService = ApiKeyService.getInstance()
+      
+      // Get all API keys
+      let apiKeys;
+      try {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Calling apiKeyService.list()'))
+        }
+        
+        apiKeys = await apiKeyService.list()
+        
+        if (isDebug) {
+          console.log(chalk.yellow(`DEBUG: Got ${apiKeys ? apiKeys.length : 0} API keys`))
+        }
+        
+        if (!apiKeys || apiKeys.length === 0) {
+          console.log(chalk.yellow('No API keys found. Create one with:'))
+          console.log(chalk.blue('  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) {
+          console.log(chalk.yellow('Authentication required. Please run `berget auth login` first.'));
+        } else {
+          console.log(chalk.red('Error fetching API keys:'));
+          if (error instanceof Error) {
+            console.log(chalk.red(error.message));
+            if (isDebug) {
+              console.log(chalk.yellow(`DEBUG: API key list error: ${error.message}`));
+              console.log(chalk.yellow(`DEBUG: Stack: ${error.stack}`));
+            }
+          }
+        }
+        return null;
+      }
+      
+      console.log(chalk.blue('Select an API key to use as default:'))
+      
+      // Display available API keys
+      apiKeys.forEach((key, index) => {
+        console.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`)
+      })
+      
+      // Create readline interface for user input
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      })
+      
+      // Prompt for selection
+      const selection = await new Promise<number>((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) {
+        console.log(chalk.yellow('No API key selected'))
+        return null
+      }
+      
+      const selectedKey = apiKeys[selection]
+      
+      // Create a new API key with the selected name
+      const newKey = await 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
+      )
+      
+      console.log(chalk.green(`✓ Default API key set to: ${newKey.name}`))
+      return newKey.key
+    } catch (error) {
+      console.error(chalk.red('Failed to set default API key:'), error)
+      return null
+    }
+  }
+}

package/src/utils/error-handler.ts

@@ -30,11 +30,11 @@ export function handleError(message: string, error: any): void {
   
   // Check for authentication errors
   if (
-    (typeof error === 'string' && error.includes('Unauthorized')) ||
-    (error && error.message && error.message.includes('Unauthorized')) ||
-    (error && error.code && error.code === 401)
+    (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.yellow('\nYou need to be logged in to use this command.'));
-    console.error(chalk.yellow('Run `berget login` to authenticate.'));
+    console.error(chalk.yellow('Run `berget auth login` to authenticate.'));
   }
 }

package/src/utils/token-manager.ts

@@ -0,0 +1,150 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import chalk from 'chalk'
+
+interface TokenData {
+  access_token: string
+  refresh_token: string
+  expires_at: number // timestamp in milliseconds
+}
+
+/**
+ * Manages authentication tokens including refresh functionality
+ */
+export class TokenManager {
+  private static instance: TokenManager
+  private tokenFilePath: string
+  private tokenData: TokenData | null = null
+  
+  private constructor() {
+    // Set up token file path in user's home directory
+    const bergetDir = path.join(os.homedir(), '.berget')
+    if (!fs.existsSync(bergetDir)) {
+      fs.mkdirSync(bergetDir, { recursive: true })
+    }
+    this.tokenFilePath = path.join(bergetDir, 'auth.json')
+    this.loadToken()
+  }
+  
+  public static getInstance(): TokenManager {
+    if (!TokenManager.instance) {
+      TokenManager.instance = new TokenManager()
+    }
+    return TokenManager.instance
+  }
+  
+  /**
+   * Load token data from file
+   */
+  private loadToken(): void {
+    try {
+      if (fs.existsSync(this.tokenFilePath)) {
+        const data = fs.readFileSync(this.tokenFilePath, 'utf8')
+        this.tokenData = JSON.parse(data)
+      }
+    } catch (error) {
+      console.error(chalk.dim('Failed to load authentication token'))
+      this.tokenData = null
+    }
+  }
+  
+  /**
+   * Save token data to file
+   */
+  private saveToken(): void {
+    try {
+      if (this.tokenData) {
+        fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.tokenData, null, 2))
+        // Set file permissions to be readable only by the owner
+        fs.chmodSync(this.tokenFilePath, 0o600)
+      } else {
+        // If token data is null, remove the file
+        if (fs.existsSync(this.tokenFilePath)) {
+          fs.unlinkSync(this.tokenFilePath)
+        }
+      }
+    } catch (error) {
+      console.error(chalk.dim('Failed to save authentication token'))
+    }
+  }
+  
+  /**
+   * Get the current access token
+   * @returns The access token or null if not available
+   */
+  public getAccessToken(): string | null {
+    if (!this.tokenData) return null
+    return this.tokenData.access_token
+  }
+  
+  /**
+   * Get the refresh token
+   * @returns The refresh token or null if not available
+   */
+  public getRefreshToken(): string | null {
+    if (!this.tokenData) return null
+    return this.tokenData.refresh_token
+  }
+  
+  /**
+   * Check if the access token is expired
+   * @returns true if expired or about to expire (within 5 minutes), false otherwise
+   */
+  public isTokenExpired(): boolean {
+    if (!this.tokenData || !this.tokenData.expires_at) return true
+    
+    try {
+      // Consider token expired if it's within 10 minutes of expiration
+      // 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.yellow(`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.dim(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`));
+      return true;
+    }
+  }
+  
+  /**
+   * Set new token data
+   * @param accessToken The new access token
+   * @param refreshToken The new refresh token
+   * @param expiresIn Expiration time in seconds
+   */
+  public setTokens(accessToken: string, refreshToken: string, expiresIn: number): void {
+    this.tokenData = {
+      access_token: accessToken,
+      refresh_token: refreshToken,
+      expires_at: Date.now() + (expiresIn * 1000)
+    }
+    this.saveToken()
+  }
+  
+  /**
+   * Update just the access token and its expiration
+   * @param accessToken The new access token
+   * @param expiresIn Expiration time in seconds
+   */
+  public updateAccessToken(accessToken: string, expiresIn: number): void {
+    if (!this.tokenData) return
+    
+    this.tokenData.access_token = accessToken
+    this.tokenData.expires_at = Date.now() + (expiresIn * 1000)
+    this.saveToken()
+  }
+  
+  /**
+   * Clear all token data
+   */
+  public clearTokens(): void {
+    this.tokenData = null
+    this.saveToken()
+  }
+}

package/tsconfig.json

@@ -39,7 +39,7 @@
     // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true,                        /* Enable importing .json files. */
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */