berget 2.2.6 → 2.2.7

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

@@ -1,41 +1,40 @@
-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 "fs";
+import * as path from "path";
+import * as os from "os";
+import { ApiKeyService } from "../services/api-key-service";
+import readline from "readline";
+import { logger } from "./logger";
 
 interface DefaultApiKeyData {
-  id: string
-  name: string
-  prefix: string
-  key: string
+  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 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()
+      DefaultApiKeyManager.instance = new DefaultApiKeyManager();
     }
-    return DefaultApiKeyManager.instance
+    return DefaultApiKeyManager.instance;
   }
 
   /**
@@ -44,12 +43,12 @@ export class DefaultApiKeyManager {
   private loadConfig(): void {
     try {
       if (fs.existsSync(this.configFilePath)) {
-        const data = fs.readFileSync(this.configFilePath, 'utf8')
-        this.defaultApiKey = JSON.parse(data)
+        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
+    } catch {
+      logger.debug("Failed to load default API key configuration");
+      this.defaultApiKey = null;
     }
   }
 
@@ -59,56 +58,48 @@ export class DefaultApiKeyManager {
   private saveConfig(): void {
     try {
       if (this.defaultApiKey) {
-        fs.writeFileSync(
-          this.configFilePath,
-          JSON.stringify(this.defaultApiKey, null, 2),
-        )
+        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)
+        fs.chmodSync(this.configFilePath, 0o600);
       } else {
         // If default API key is null, remove the file
         if (fs.existsSync(this.configFilePath)) {
-          fs.unlinkSync(this.configFilePath)
+          fs.unlinkSync(this.configFilePath);
         }
       }
-    } catch (error) {
-      logger.debug('Failed to save default API key configuration')
+    } catch {
+      logger.debug("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()
+  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
+    return this.defaultApiKey?.key || null;
   }
 
   /**
    * Get the default API key data object
    */
   public getDefaultApiKeyData(): DefaultApiKeyData | null {
-    return this.defaultApiKey
+    return this.defaultApiKey;
   }
 
   /**
    * Clear the default API key
    */
   public clearDefaultApiKey(): void {
-    this.defaultApiKey = null
-    this.saveConfig()
+    this.defaultApiKey = null;
+    this.saveConfig();
   }
 
   /**
@@ -117,108 +108,105 @@ export class DefaultApiKeyManager {
    */
   public async promptForDefaultApiKey(): Promise<string | null> {
     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("Unauthorized") ||
+          errorMessage.includes("Authentication 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}...)`)
-      })
+        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)
+      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
+            resolve(-1); // Invalid selection
           } else {
-            resolve(num - 1) // Convert to zero-based index
+            resolve(num - 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',
-      })
+        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,
-      )
+        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;
     }
   }
 }

package/src/utils/env-manager.ts

@@ -1,79 +1,75 @@
-import fs from 'fs'
-import path from 'path'
-import { writeFile } from 'fs/promises'
-import chalk from 'chalk'
-import dotenv from 'dotenv'
+import fs from "fs";
+import path from "path";
+import { writeFile } from "fs/promises";
+import chalk from "chalk";
+import dotenv from "dotenv";
 
 export interface EnvUpdateOptions {
-  envPath?: string
-  key: string
-  value: string
-  comment?: string
-  force?: boolean
+  envPath?: string;
+  key: string;
+  value: string;
+  comment?: string;
+  force?: boolean;
 }
 
 /**
  * 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'),
+    envPath = path.join(process.cwd(), ".env"),
     key,
     value,
     comment,
     force = false,
-  } = options
+  } = 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)
+      existingContent = fs.readFileSync(envPath, "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`
+      newContent += `${envKey}=${envValue}\n`;
     }
 
     // Write the updated content
-    await writeFile(envPath, newContent.trim() + '\n')
+    await writeFile(envPath, 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
+    console.error(chalk.red(`Failed to update .env file:`));
+    throw error;
   }
 }
 
@@ -81,18 +77,18 @@ export async function updateEnvFile(
  * Checks if a .env file exists and contains a specific key
  */
 export function hasEnvKey(
-  envPath: string = path.join(process.cwd(), '.env'),
-  key: string,
+  envPath: string = path.join(process.cwd(), ".env"),
+  key: string
 ): boolean {
   if (!fs.existsSync(envPath)) {
-    return false
+    return false;
   }
 
   try {
-    const content = fs.readFileSync(envPath, 'utf8')
-    const parsed = dotenv.parse(content)
-    return key in parsed
+    const content = fs.readFileSync(envPath, "utf8");
+    const parsed = dotenv.parse(content);
+    return key in parsed;
   } catch {
-    return false
+    return false;
   }
 }