berget 1.0.0 → 1.2.0

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

@@ -0,0 +1,237 @@
+"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) {
+        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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+/**
+ * Manages the default API key for chat commands
+ */
+class DefaultApiKeyManager {
+    constructor() {
+        this.defaultApiKey = null;
+        // 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();
+    }
+    static getInstance() {
+        if (!DefaultApiKeyManager.instance) {
+            DefaultApiKeyManager.instance = new DefaultApiKeyManager();
+        }
+        return DefaultApiKeyManager.instance;
+    }
+    /**
+     * Load default API key from file
+     */
+    loadConfig() {
+        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_1.default.dim('Failed to load default API key configuration'));
+            }
+            this.defaultApiKey = null;
+        }
+    }
+    /**
+     * Save default API key to file
+     */
+    saveConfig() {
+        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_1.default.dim('Failed to save default API key configuration'));
+            }
+        }
+    }
+    /**
+     * Set the default API key
+     */
+    setDefaultApiKey(id, name, prefix, key) {
+        this.defaultApiKey = { id, name, prefix, key };
+        this.saveConfig();
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Clear the default API key
+     */
+    clearDefaultApiKey() {
+        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 {
+                const isDebug = process.argv.includes('--debug');
+                if (isDebug) {
+                    console.log(chalk_1.default.yellow('DEBUG: promptForDefaultApiKey called'));
+                }
+                // If we already have a default API key, return it
+                if (this.defaultApiKey) {
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow('DEBUG: Using existing default API key'));
+                    }
+                    return this.defaultApiKey.key;
+                }
+                if (isDebug) {
+                    console.log(chalk_1.default.yellow('DEBUG: No default API key found, getting ApiKeyService'));
+                }
+                const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+                // Get all API keys
+                let apiKeys;
+                try {
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow('DEBUG: Calling apiKeyService.list()'));
+                    }
+                    apiKeys = yield apiKeyService.list();
+                    if (isDebug) {
+                        console.log(chalk_1.default.yellow(`DEBUG: Got ${apiKeys ? apiKeys.length : 0} API keys`));
+                    }
+                    if (!apiKeys || apiKeys.length === 0) {
+                        console.log(chalk_1.default.yellow('No API keys found. Create one with:'));
+                        console.log(chalk_1.default.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_1.default.yellow('Authentication required. Please run `berget auth login` first.'));
+                    }
+                    else {
+                        console.log(chalk_1.default.red('Error fetching API keys:'));
+                        if (error instanceof Error) {
+                            console.log(chalk_1.default.red(error.message));
+                            if (isDebug) {
+                                console.log(chalk_1.default.yellow(`DEBUG: API key list error: ${error.message}`));
+                                console.log(chalk_1.default.yellow(`DEBUG: Stack: ${error.stack}`));
+                            }
+                        }
+                    }
+                    return null;
+                }
+                console.log(chalk_1.default.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_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) {
+                    console.log(chalk_1.default.yellow('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);
+                console.log(chalk_1.default.green(`✓ Default API key set to: ${newKey.name}`));
+                return newKey.key;
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('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;

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

@@ -0,0 +1,165 @@
+"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 __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"));
+/**
+ * Manages authentication tokens including refresh functionality
+ */
+class TokenManager {
+    constructor() {
+        this.tokenData = null;
+        // 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();
+    }
+    static getInstance() {
+        if (!TokenManager.instance) {
+            TokenManager.instance = new TokenManager();
+        }
+        return TokenManager.instance;
+    }
+    /**
+     * Load token data from file
+     */
+    loadToken() {
+        try {
+            if (fs.existsSync(this.tokenFilePath)) {
+                const data = fs.readFileSync(this.tokenFilePath, 'utf8');
+                this.tokenData = JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.dim('Failed to load authentication token'));
+            this.tokenData = null;
+        }
+    }
+    /**
+     * Save token data to file
+     */
+    saveToken() {
+        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_1.default.dim('Failed to save authentication token'));
+        }
+    }
+    /**
+     * Get the current access token
+     * @returns The access token or null if not available
+     */
+    getAccessToken() {
+        if (!this.tokenData)
+            return null;
+        return this.tokenData.access_token;
+    }
+    /**
+     * Get the refresh token
+     * @returns The refresh token or null if not available
+     */
+    getRefreshToken() {
+        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
+     */
+    isTokenExpired() {
+        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_1.default.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_1.default.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
+     */
+    setTokens(accessToken, refreshToken, expiresIn) {
+        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
+     */
+    updateAccessToken(accessToken, expiresIn) {
+        if (!this.tokenData)
+            return;
+        this.tokenData.access_token = accessToken;
+        this.tokenData.expires_at = Date.now() + (expiresIn * 1000);
+        this.saveToken();
+    }
+    /**
+     * Clear all token data
+     */
+    clearTokens() {
+        this.tokenData = null;
+        this.saveToken();
+    }
+}
+exports.TokenManager = TokenManager;