berget 2.2.6 → 2.2.8

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

@@ -1,224 +1,213 @@
-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'
-import { logger } from './logger'
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import readline from 'node:readline';
+
+import { ApiKeyService } from '../services/api-key-service';
+import { logger } from './logger';
 
 interface DefaultApiKeyData {
-  id: string
-  name: string
-  prefix: string
-  key: string
+  id: string;
+  key: string;
+  name: string;
+  prefix: 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 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')
+    const bergetDir = path.join(os.homedir(), '.berget');
     if (!fs.existsSync(bergetDir)) {
-      fs.mkdirSync(bergetDir, { recursive: true })
+      fs.mkdirSync(bergetDir, { recursive: true });
     }
-    this.configFilePath = path.join(bergetDir, 'default-api-key.json')
-    this.loadConfig()
+    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) {
-      logger.debug('Failed to load default API key configuration')
-      this.defaultApiKey = null
+      DefaultApiKeyManager.instance = new DefaultApiKeyManager();
     }
+    return DefaultApiKeyManager.instance;
   }
 
   /**
-   * 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) {
-      logger.debug('Failed to save default API key configuration')
-    }
-  }
-
-  /**
-   * Set the default API key
+   * Clear the default API key
    */
-  public setDefaultApiKey(
-    id: string,
-    name: string,
-    prefix: string,
-    key: string,
-  ): void {
-    this.defaultApiKey = { id, name, prefix, key }
-    this.saveConfig()
+  public clearDefaultApiKey(): void {
+    this.defaultApiKey = null;
+    this.saveConfig();
   }
 
   /**
    * Get the default API key string
    */
-  public getDefaultApiKey(): string | null {
-    return this.defaultApiKey?.key || null
+  public getDefaultApiKey(): null | string {
+    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()
+    return this.defaultApiKey;
   }
 
   /**
    * 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> {
+  public async promptForDefaultApiKey(): Promise<null | string> {
     try {
-      logger.debug('promptForDefaultApiKey called')
+      logger.debug('promptForDefaultApiKey called');
 
       // If we already have a default API key, return it
       if (this.defaultApiKey) {
-        logger.debug('Using existing default API key')
-        return this.defaultApiKey.key
+        logger.debug('Using existing default API key');
+        return this.defaultApiKey.key;
       }
 
-      logger.debug('No default API key found, getting ApiKeyService')
+      logger.debug('No default API key found, getting ApiKeyService');
 
-      const apiKeyService = ApiKeyService.getInstance()
+      const apiKeyService = ApiKeyService.getInstance();
 
       // Get all API keys
-      let apiKeys
+      let apiKeys;
       try {
-        logger.debug('Calling apiKeyService.list()')
+        logger.debug('Calling apiKeyService.list()');
 
-        apiKeys = await apiKeyService.list()
+        apiKeys = await apiKeyService.list();
 
-        logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`)
+        logger.debug(`Got ${apiKeys ? apiKeys.length : 0} API keys`);
 
         if (!apiKeys || apiKeys.length === 0) {
-          logger.warn('No API keys found. Create one with:')
-          logger.info('  berget api-keys create --name "My Key"')
-          return null
+          logger.warn('No API keys found. Create one with:');
+          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 errorMessage = error instanceof Error ? error.message : String(error);
         const isAuthError =
           errorMessage.includes('Unauthorized') ||
           errorMessage.includes('Authentication failed') ||
-          errorMessage.includes('AUTH_FAILED')
+          errorMessage.includes('AUTH_FAILED');
 
         if (isAuthError) {
-          logger.warn(
-            'Authentication required. Please run `berget auth login` first.',
-          )
+          logger.warn('Authentication required. Please run `berget auth login` first.');
         } else {
-          logger.error('Error fetching API keys:')
+          logger.error('Error fetching API keys:');
           if (error instanceof Error) {
-            logger.error(error.message)
-            logger.debug(`API key list error: ${error.message}`)
-            logger.debug(`Stack: ${error.stack}`)
+            logger.error(error.message);
+            logger.debug(`API key list error: ${error.message}`);
+            logger.debug(`Stack: ${error.stack}`);
           }
         }
-        return null
+        return null;
       }
 
-      logger.info('Select an API key to use as default:')
+      logger.info('Select an API key to use as default:');
 
       // Display available API keys
-      apiKeys.forEach((key, index) => {
-        logger.log(`  ${index + 1}. ${key.name} (${key.prefix}...)`)
-      })
+      for (const [index, key] of apiKeys.entries()) {
+        logger.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
+          rl.close();
+          const number_ = Number.parseInt(answer.trim(), 10);
+          if (isNaN(number_) || number_ < 1 || number_ > apiKeys.length) {
+            resolve(-1); // Invalid selection
           } else {
-            resolve(num - 1) // Convert to zero-based index
+            resolve(number_ - 1); // Convert to zero-based index
           }
-        })
-      })
+        });
+      });
 
       if (selection === -1) {
-        logger.warn('No API key selected')
-        return null
+        logger.warn('No API key selected');
+        return null;
       }
 
-      const selectedKey = apiKeys[selection]
+      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',
-      })
+        name: `CLI Default (copy of ${selectedKey.name})`,
+      });
 
       // 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.slice(0, 8), // Use first 8 chars as prefix
         newKey.key,
-      )
+      );
 
-      logger.success(`✓ Default API key set to: ${newKey.name}`)
-      return newKey.key
+      logger.success(`✓ Default API key set to: ${newKey.name}`);
+      return newKey.key;
     } catch (error) {
-      logger.error('Failed to set default API key:', error)
-      return null
+      logger.error('Failed to set default API key:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Set the default API key
+   */
+  public setDefaultApiKey(id: string, name: string, prefix: string, key: string): void {
+    this.defaultApiKey = { id, key, name, prefix };
+    this.saveConfig();
+  }
+
+  /**
+   * 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 {
+      logger.debug('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 {
+      logger.debug('Failed to save default API key configuration');
     }
   }
 }

package/src/utils/env-manager.ts

@@ -1,98 +1,94 @@
-import fs from 'fs'
-import path from 'path'
-import { writeFile } from 'fs/promises'
-import chalk from 'chalk'
-import dotenv from 'dotenv'
+import chalk from 'chalk';
+import dotenv from 'dotenv';
+import fs from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
 
 export interface EnvUpdateOptions {
-  envPath?: string
-  key: string
-  value: string
-  comment?: string
-  force?: boolean
+  comment?: string;
+  envPath?: string;
+  force?: boolean;
+  key: string;
+  value: string;
+}
+
+/**
+ * Checks if a .env file exists and contains a specific key
+ */
+export function hasEnvKey(
+  environmentPath: string = path.join(process.cwd(), '.env'),
+  key: string,
+): boolean {
+  if (!fs.existsSync(environmentPath)) {
+    return false;
+  }
+
+  try {
+    const content = fs.readFileSync(environmentPath, 'utf8');
+    const parsed = dotenv.parse(content);
+    return key in parsed;
+  } catch {
+    return false;
+  }
 }
 
 /**
  * Safely updates .env file without overwriting existing keys
  * Uses dotenv for proper parsing and formatting
  */
-export async function updateEnvFile(
-  options: EnvUpdateOptions,
-): Promise<boolean> {
+export async function updateEnvFile(options: EnvUpdateOptions): Promise<boolean> {
   const {
-    envPath = path.join(process.cwd(), '.env'),
-    key,
-    value,
     comment,
+    envPath: environmentPath = path.join(process.cwd(), '.env'),
     force = false,
-  } = options
+    key,
+    value,
+  } = options;
 
   try {
-    let existingContent = ''
-    let parsed: Record<string, string> = {}
+    let existingContent = '';
+    let parsed: Record<string, string> = {};
 
     // Read existing .env file if it exists
-    if (fs.existsSync(envPath)) {
-      existingContent = fs.readFileSync(envPath, 'utf8')
-      parsed = dotenv.parse(existingContent)
+    if (fs.existsSync(environmentPath)) {
+      existingContent = fs.readFileSync(environmentPath, 'utf8');
+      parsed = dotenv.parse(existingContent);
     }
 
     // Check if key already exists and we're not forcing
     if (parsed[key] && !force) {
-      console.log(
-        chalk.yellow(`⚠ ${key} already exists in .env - leaving unchanged`),
-      )
-      return false
+      console.log(chalk.yellow(`⚠ ${key} already exists in .env - leaving unchanged`));
+      return false;
     }
 
     // Update the parsed object
-    parsed[key] = value
+    parsed[key] = value;
 
     // Generate new .env content
-    let newContent = ''
+    let newContent = '';
 
     // Add comment at the top if this is a new file
     if (!existingContent && comment) {
-      newContent += `# ${comment}\n`
+      newContent += `# ${comment}\n`;
     }
 
     // Convert parsed object back to .env format
-    for (const [envKey, envValue] of Object.entries(parsed)) {
-      newContent += `${envKey}=${envValue}\n`
+    for (const [environmentKey, environmentValue] of Object.entries(parsed)) {
+      newContent += `${environmentKey}=${environmentValue}\n`;
     }
 
     // Write the updated content
-    await writeFile(envPath, newContent.trim() + '\n')
+    await writeFile(environmentPath, newContent.trim() + '\n');
 
     if (existingContent) {
-      console.log(chalk.green(`✓ Updated .env with ${key}`))
+      console.log(chalk.green(`✓ Updated .env with ${key}`));
     } else {
-      console.log(chalk.green(`✓ Created .env with ${key}`))
+      console.log(chalk.green(`✓ Created .env with ${key}`));
     }
 
-    return true
+    return true;
   } catch (error) {
-    console.error(chalk.red(`Failed to update .env file:`))
-    throw error
-  }
-}
-
-/**
- * Checks if a .env file exists and contains a specific key
- */
-export function hasEnvKey(
-  envPath: string = path.join(process.cwd(), '.env'),
-  key: string,
-): boolean {
-  if (!fs.existsSync(envPath)) {
-    return false
-  }
-
-  try {
-    const content = fs.readFileSync(envPath, 'utf8')
-    const parsed = dotenv.parse(content)
-    return key in parsed
-  } catch {
-    return false
+    console.error(chalk.red(`Failed to update .env file:`));
+    throw error;
   }
 }