berget 1.0.0 → 1.1.0

package/dist/src/client.js

@@ -1,46 +1,27 @@
 "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.createAuthenticatedClient = exports.clearAuthToken = exports.saveAuthToken = exports.isTokenExpired = exports.getAuthToken = exports.apiClient = void 0;
+exports.createAuthenticatedClient = exports.clearAuthToken = exports.saveAuthToken = exports.getAuthToken = exports.apiClient = void 0;
 const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
 const chalk_1 = __importDefault(require("chalk"));
-// Configuration directory
-const CONFIG_DIR = path.join(os.homedir(), '.berget');
-const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+const token_manager_1 = require("./utils/token-manager");
 // API Base URL
 // Use --local flag to test against local API
 const isLocalMode = process.argv.includes('--local');
 const API_BASE_URL = process.env.BERGET_API_URL ||
     (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai');
-if (isLocalMode && !process.env.BERGET_API_URL) {
+if (isLocalMode && !process.env.BERGET_API_URL && process.argv.includes('--debug')) {
     console.log(chalk_1.default.yellow('Using local API endpoint: http://localhost:3000'));
 }
 // Create a typed client for the Berget API
@@ -53,89 +34,32 @@ exports.apiClient = (0, openapi_fetch_1.default)({
 });
 // Authentication functions
 const getAuthToken = () => {
-    try {
-        if (fs.existsSync(TOKEN_FILE)) {
-            const tokenData = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
-            return tokenData.accessToken;
-        }
-    }
-    catch (error) {
-        console.error('Error reading auth token:', error);
-    }
-    return null;
+    const tokenManager = token_manager_1.TokenManager.getInstance();
+    return tokenManager.getAccessToken();
 };
 exports.getAuthToken = getAuthToken;
-// Check if token is expired (JWT tokens have an exp claim)
-const isTokenExpired = (token) => {
-    try {
-        const base64Url = token.split('.')[1];
-        const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
-        const jsonPayload = decodeURIComponent(atob(base64)
-            .split('')
-            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
-            .join(''));
-        const payload = JSON.parse(jsonPayload);
-        // Check if token has expired
-        if (payload.exp) {
-            return payload.exp * 1000 < Date.now();
-        }
-    }
-    catch (error) {
-        // If we can't decode the token, assume it's expired
-        return true;
-    }
-    // If there's no exp claim, assume it's valid
-    return false;
-};
-exports.isTokenExpired = isTokenExpired;
-const saveAuthToken = (token) => {
-    try {
-        if (!fs.existsSync(CONFIG_DIR)) {
-            fs.mkdirSync(CONFIG_DIR, { recursive: true });
-        }
-        fs.writeFileSync(TOKEN_FILE, JSON.stringify({ accessToken: token }), 'utf8');
-        // Set file permissions to be readable only by the owner
-        fs.chmodSync(TOKEN_FILE, 0o600);
-    }
-    catch (error) {
-        console.error('Error saving auth token:', error);
-    }
+const saveAuthToken = (accessToken, refreshToken, expiresIn = 3600) => {
+    const tokenManager = token_manager_1.TokenManager.getInstance();
+    tokenManager.setTokens(accessToken, refreshToken, expiresIn);
 };
 exports.saveAuthToken = saveAuthToken;
 const clearAuthToken = () => {
-    try {
-        if (fs.existsSync(TOKEN_FILE)) {
-            fs.unlinkSync(TOKEN_FILE);
-        }
-    }
-    catch (error) {
-        console.error('Error clearing auth token:', error);
-    }
+    const tokenManager = token_manager_1.TokenManager.getInstance();
+    tokenManager.clearTokens();
 };
 exports.clearAuthToken = clearAuthToken;
-// Create an authenticated client
+// Create an authenticated client with refresh token support
 const createAuthenticatedClient = () => {
-    const token = (0, exports.getAuthToken)();
-    if (!token) {
-        console.warn(chalk_1.default.yellow('No authentication token found. Please run `berget login` first.'));
+    const tokenManager = token_manager_1.TokenManager.getInstance();
+    if (!tokenManager.getAccessToken() && process.argv.includes('--debug')) {
+        console.warn(chalk_1.default.yellow('No authentication token found. Please run `berget auth login` first.'));
     }
-    else if ((0, exports.isTokenExpired)(token)) {
-        console.warn(chalk_1.default.yellow('Your authentication token has expired. Please run `berget login` to get a new token.'));
-        // Optionally clear the expired token
-        (0, exports.clearAuthToken)();
-        return (0, openapi_fetch_1.default)({
-            baseUrl: API_BASE_URL,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-        });
-    }
-    return (0, openapi_fetch_1.default)({
+    // Create the base client
+    const client = (0, openapi_fetch_1.default)({
         baseUrl: API_BASE_URL,
-        headers: token
+        headers: tokenManager.getAccessToken()
             ? {
-                Authorization: `Bearer ${token}`,
+                Authorization: `Bearer ${tokenManager.getAccessToken()}`,
                 'Content-Type': 'application/json',
                 Accept: 'application/json',
             }
@@ -144,5 +68,172 @@ const createAuthenticatedClient = () => {
                 Accept: 'application/json',
             },
     });
+    // Wrap the client to handle token refresh
+    return new Proxy(client, {
+        get(target, prop) {
+            // For HTTP methods (GET, POST, etc.), add token refresh logic
+            if (typeof target[prop] === 'function' &&
+                ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(String(prop))) {
+                return (...args) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    // Check if token is expired before making the request
+                    if (tokenManager.isTokenExpired() && tokenManager.getRefreshToken()) {
+                        yield refreshAccessToken(tokenManager);
+                    }
+                    // Update the Authorization header with the current token
+                    if (tokenManager.getAccessToken()) {
+                        if (!args[1])
+                            args[1] = {};
+                        if (!args[1].headers)
+                            args[1].headers = {};
+                        args[1].headers.Authorization = `Bearer ${tokenManager.getAccessToken()}`;
+                    }
+                    // Make the original request
+                    let result;
+                    try {
+                        result = yield target[prop](...args);
+                    }
+                    catch (requestError) {
+                        if (process.argv.includes('--debug')) {
+                            console.log(chalk_1.default.red(`DEBUG: Request error: ${requestError instanceof Error
+                                ? requestError.message
+                                : String(requestError)}`));
+                        }
+                        return {
+                            error: {
+                                message: `Request failed: ${requestError instanceof Error
+                                    ? requestError.message
+                                    : String(requestError)}`,
+                            },
+                        };
+                    }
+                    // If we get an auth error, try to refresh the token and retry
+                    if (result.error) {
+                        // Detect various forms of authentication errors
+                        const isAuthError = 
+                        // Standard 401 Unauthorized
+                        (typeof result.error === 'object' && result.error.status === 401) ||
+                            // OAuth specific errors
+                            (result.error.error &&
+                                (result.error.error.code === 'invalid_token' ||
+                                    result.error.error.code === 'token_expired' ||
+                                    result.error.error.message === 'Invalid API key' ||
+                                    ((_a = result.error.error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes('token')) ||
+                                    ((_b = result.error.error.message) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('unauthorized')))) ||
+                            // Message-based detection as fallback
+                            (typeof result.error === 'string' &&
+                                (result.error.toLowerCase().includes('unauthorized') ||
+                                    result.error.toLowerCase().includes('token') ||
+                                    result.error.toLowerCase().includes('auth')));
+                        if (isAuthError && tokenManager.getRefreshToken()) {
+                            if (process.argv.includes('--debug')) {
+                                console.log(chalk_1.default.yellow('DEBUG: Auth error detected, attempting token refresh'));
+                                console.log(chalk_1.default.yellow(`DEBUG: Error details: ${JSON.stringify(result.error, null, 2)}`));
+                            }
+                            const refreshed = yield refreshAccessToken(tokenManager);
+                            if (refreshed) {
+                                if (process.argv.includes('--debug')) {
+                                    console.log(chalk_1.default.green('DEBUG: Token refreshed successfully, retrying request'));
+                                }
+                                // Update the Authorization header with the new token
+                                if (!args[1])
+                                    args[1] = {};
+                                if (!args[1].headers)
+                                    args[1].headers = {};
+                                args[1].headers.Authorization = `Bearer ${tokenManager.getAccessToken()}`;
+                                // Retry the request
+                                return yield target[prop](...args);
+                            }
+                            else {
+                                if (process.argv.includes('--debug')) {
+                                    console.log(chalk_1.default.red('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.';
+                                }
+                            }
+                        }
+                    }
+                    return result;
+                });
+            }
+            // For other properties, just return the original
+            return target[prop];
+        },
+    });
 };
 exports.createAuthenticatedClient = createAuthenticatedClient;
+// Helper function to refresh the access token
+function refreshAccessToken(tokenManager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const refreshToken = tokenManager.getRefreshToken();
+            if (!refreshToken)
+                return false;
+            if (process.argv.includes('--debug')) {
+                console.log(chalk_1.default.yellow('DEBUG: Attempting to refresh access token'));
+            }
+            // Use fetch directly since this endpoint might not be in the OpenAPI spec
+            try {
+                const response = yield fetch(`${API_BASE_URL}/v1/auth/refresh`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: JSON.stringify({ refresh_token: refreshToken }),
+                });
+                // Handle HTTP errors
+                if (!response.ok) {
+                    if (process.argv.includes('--debug')) {
+                        console.log(chalk_1.default.yellow(`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) {
+                        console.warn(chalk_1.default.yellow('Your refresh token has expired. Please run `berget auth login` again.'));
+                        // Clear tokens if unauthorized - they're invalid
+                        tokenManager.clearTokens();
+                    }
+                    else {
+                        console.warn(chalk_1.default.yellow(`Failed to refresh token: ${response.status} ${response.statusText}`));
+                    }
+                    return false;
+                }
+                // Parse the response
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.includes('application/json')) {
+                    console.warn(chalk_1.default.yellow(`Unexpected content type in response: ${contentType}`));
+                    return false;
+                }
+                const data = yield response.json();
+                // Validate the response data
+                if (!data || !data.token) {
+                    console.warn(chalk_1.default.yellow('Invalid token response. Please run `berget auth login` again.'));
+                    return false;
+                }
+                if (process.argv.includes('--debug')) {
+                    console.log(chalk_1.default.green('DEBUG: Token refreshed successfully'));
+                }
+                // Update the token
+                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_1.default.green('DEBUG: Refresh token also updated'));
+                    }
+                }
+            }
+            catch (fetchError) {
+                console.warn(chalk_1.default.yellow(`Failed to refresh token: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`));
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`Failed to refresh authentication token: ${error instanceof Error ? error.message : String(error)}`));
+            return false;
+        }
+    });
+}

package/dist/src/commands/api-keys.js

@@ -0,0 +1,271 @@
+"use strict";
+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.registerApiKeyCommands = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const api_key_service_1 = require("../services/api-key-service");
+const error_handler_1 = require("../utils/error-handler");
+const default_api_key_1 = require("../utils/default-api-key");
+/**
+ * Register API key commands
+ */
+function registerApiKeyCommands(program) {
+    const apiKey = program
+        .command(api_key_service_1.ApiKeyService.COMMAND_GROUP)
+        .description('Manage API keys');
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.LIST)
+        .description('List all API keys')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            const keys = yield apiKeyService.list();
+            if (keys.length === 0) {
+                console.log(chalk_1.default.yellow('No API keys found. Create one with `berget api-key create --name <name>`'));
+                return;
+            }
+            console.log(chalk_1.default.bold('Your API keys:'));
+            console.log('');
+            // Create a table-like format with headers
+            console.log(chalk_1.default.dim('ID'.padEnd(10)) +
+                chalk_1.default.dim('NAME'.padEnd(25)) +
+                chalk_1.default.dim('PREFIX'.padEnd(12)) +
+                chalk_1.default.dim('STATUS'.padEnd(12)) +
+                chalk_1.default.dim('CREATED'.padEnd(12)) +
+                chalk_1.default.dim('LAST USED'));
+            console.log(chalk_1.default.dim('─'.repeat(85)));
+            keys.forEach((key) => {
+                const lastUsed = key.lastUsed ? key.lastUsed.substring(0, 10) : 'Never';
+                const status = key.active
+                    ? chalk_1.default.green('● Active')
+                    : chalk_1.default.red('● Inactive');
+                console.log(String(key.id).padEnd(10) +
+                    key.name.padEnd(25) +
+                    key.prefix.padEnd(12) +
+                    status.padEnd(12) +
+                    key.created.substring(0, 10).padEnd(12) +
+                    lastUsed);
+            });
+            console.log('');
+            console.log(chalk_1.default.dim('Use `berget api-key create --name <name>` to create a new API key'));
+            console.log(chalk_1.default.dim('Use `berget api-key delete <id>` to delete an API key'));
+            console.log(chalk_1.default.dim('Use `berget api-key rotate <id>` to rotate an API key'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to list API keys', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.CREATE)
+        .description('Create a new API key')
+        .option('--name <name>', 'Name of the API key')
+        .option('--description <description>', 'Description of the API key')
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!options.name) {
+                console.error(chalk_1.default.red('Error: --name is required'));
+                console.log('');
+                console.log('Usage: berget api-key create --name <name> [--description <description>]');
+                return;
+            }
+            console.log(chalk_1.default.blue('Creating API key...'));
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            const result = yield apiKeyService.create({
+                name: options.name,
+                description: options.description,
+            });
+            console.log('');
+            console.log(chalk_1.default.green('✓ API key created'));
+            console.log('');
+            console.log(chalk_1.default.bold('API key details:'));
+            console.log('');
+            console.log(`${chalk_1.default.dim('ID:')}          ${result.id}`);
+            console.log(`${chalk_1.default.dim('Name:')}        ${result.name}`);
+            if (result.description) {
+                console.log(`${chalk_1.default.dim('Description:')} ${result.description}`);
+            }
+            console.log(`${chalk_1.default.dim('Created:')}     ${new Date(result.created).toLocaleString()}`);
+            console.log('');
+            console.log(chalk_1.default.bold('API key:'));
+            console.log(chalk_1.default.cyan(result.key));
+            console.log('');
+            console.log(chalk_1.default.yellow('⚠️  IMPORTANT: Save this API key in a secure location.'));
+            console.log(chalk_1.default.yellow('   It will not be displayed again.'));
+            console.log('');
+            console.log(chalk_1.default.dim('Use this key in your applications to authenticate with the Berget API.'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to create API key', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.DELETE)
+        .description('Delete an API key')
+        .argument('<id>', 'ID of the API key to delete')
+        .action((id) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log(chalk_1.default.blue(`Deleting API key ${id}...`));
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            yield apiKeyService.delete(id);
+            console.log(chalk_1.default.green(`✓ API key ${id} has been deleted`));
+            console.log('');
+            console.log(chalk_1.default.dim('Applications using this key will no longer be able to authenticate.'));
+            console.log(chalk_1.default.dim('Use `berget api-key list` to see your remaining API keys.'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to delete API key', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.ROTATE)
+        .description('Rotate an API key (creates a new one and invalidates the old one)')
+        .argument('<id>', 'ID of the API key to rotate')
+        .action((id) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log(chalk_1.default.blue(`Rotating API key ${id}...`));
+            console.log(chalk_1.default.dim('This will invalidate the old key and generate a new one.'));
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            const result = yield apiKeyService.rotate(id);
+            console.log('');
+            console.log(chalk_1.default.green('✓ API key rotated'));
+            console.log('');
+            console.log(chalk_1.default.bold('New API key details:'));
+            console.log('');
+            console.log(`${chalk_1.default.dim('ID:')}          ${result.id}`);
+            console.log(`${chalk_1.default.dim('Name:')}        ${result.name}`);
+            if (result.description) {
+                console.log(`${chalk_1.default.dim('Description:')} ${result.description}`);
+            }
+            console.log(`${chalk_1.default.dim('Created:')}     ${new Date(result.created).toLocaleString()}`);
+            console.log('');
+            console.log(chalk_1.default.bold('New API key:'));
+            console.log(chalk_1.default.cyan(result.key));
+            console.log('');
+            console.log(chalk_1.default.yellow('⚠️  IMPORTANT: Update your applications with this new API key.'));
+            console.log(chalk_1.default.yellow('   The old key has been invalidated and will no longer work.'));
+            console.log(chalk_1.default.yellow('   This new key will not be displayed again.'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to rotate API key', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.DESCRIBE)
+        .description('Show usage statistics for an API key')
+        .argument('<id>', 'ID of the API key')
+        .option('--start <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end <date>', 'End date (YYYY-MM-DD)')
+        .action((id, options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log(chalk_1.default.blue(`Fetching usage statistics for API key ${id}...`));
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            const usage = yield apiKeyService.describe(id);
+            console.log('');
+            console.log(chalk_1.default.bold(`Usage statistics for API key: ${usage.name} (${id})`));
+            console.log('');
+            // Period information
+            console.log(chalk_1.default.dim(`Period: ${usage.period.start} to ${usage.period.end}`));
+            console.log('');
+            // Request statistics
+            console.log(chalk_1.default.bold('Request statistics:'));
+            console.log(`Total requests: ${chalk_1.default.cyan(usage.requests.total.toLocaleString())}`);
+            // Daily breakdown if available
+            if (usage.requests.daily && usage.requests.daily.length > 0) {
+                console.log('');
+                console.log(chalk_1.default.bold('Daily breakdown:'));
+                console.log(chalk_1.default.dim('─'.repeat(30)));
+                console.log(chalk_1.default.dim('DATE'.padEnd(12) + 'REQUESTS'));
+                usage.requests.daily.forEach((day) => {
+                    console.log(`${day.date.padEnd(12)}${day.count.toLocaleString()}`);
+                });
+            }
+            // Model usage if available
+            if (usage.models && usage.models.length > 0) {
+                console.log('');
+                console.log(chalk_1.default.bold('Model usage:'));
+                console.log(chalk_1.default.dim('─'.repeat(70)));
+                console.log(chalk_1.default.dim('MODEL'.padEnd(20)) +
+                    chalk_1.default.dim('REQUESTS'.padEnd(10)) +
+                    chalk_1.default.dim('INPUT'.padEnd(12)) +
+                    chalk_1.default.dim('OUTPUT'.padEnd(12)) +
+                    chalk_1.default.dim('TOTAL TOKENS'));
+                usage.models.forEach((model) => {
+                    console.log(model.name.padEnd(20) +
+                        model.requests.toString().padEnd(10) +
+                        model.tokens.input.toLocaleString().padEnd(12) +
+                        model.tokens.output.toLocaleString().padEnd(12) +
+                        model.tokens.total.toLocaleString());
+                });
+            }
+            console.log('');
+            console.log(chalk_1.default.dim('Use these statistics to understand your API usage and optimize your costs.'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to get API key usage', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.SET_DEFAULT)
+        .description('Set an API key as the default for chat commands')
+        .argument('<id>', 'ID of the API key to set as default')
+        .action((id) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+            const keys = yield apiKeyService.list();
+            const selectedKey = keys.find(key => key.id.toString() === id);
+            if (!selectedKey) {
+                console.error(chalk_1.default.red(`Error: API key with ID ${id} not found`));
+                return;
+            }
+            // Save the default API key
+            const defaultApiKeyManager = default_api_key_1.DefaultApiKeyManager.getInstance();
+            defaultApiKeyManager.setDefaultApiKey(id, selectedKey.name, selectedKey.prefix);
+            console.log(chalk_1.default.green(`✓ API key "${selectedKey.name}" set as default for chat commands`));
+            console.log('');
+            console.log(chalk_1.default.dim('This API key will be used by default when running chat commands'));
+            console.log(chalk_1.default.dim('You can override it with --api-key or --api-key-id options'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to set default API key', error);
+        }
+    }));
+    apiKey
+        .command(api_key_service_1.ApiKeyService.COMMANDS.GET_DEFAULT)
+        .description('Show the current default API key')
+        .action(() => {
+        try {
+            const defaultApiKeyManager = default_api_key_1.DefaultApiKeyManager.getInstance();
+            const defaultApiKey = defaultApiKeyManager.getDefaultApiKey();
+            if (!defaultApiKey) {
+                console.log(chalk_1.default.yellow('No default API key set'));
+                console.log('');
+                console.log('To set a default API key, run:');
+                console.log(chalk_1.default.cyan('  berget api-keys set-default <id>'));
+                return;
+            }
+            console.log(chalk_1.default.bold('Default API key:'));
+            console.log('');
+            console.log(`${chalk_1.default.dim('ID:')}     ${defaultApiKey.id}`);
+            console.log(`${chalk_1.default.dim('Name:')}   ${defaultApiKey.name}`);
+            console.log(`${chalk_1.default.dim('Prefix:')} ${defaultApiKey.prefix}`);
+            console.log('');
+            console.log(chalk_1.default.dim('This API key will be used by default when running chat commands'));
+            console.log(chalk_1.default.dim('You can override it with --api-key or --api-key-id options'));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to get default API key', error);
+        }
+    });
+}
+exports.registerApiKeyCommands = registerApiKeyCommands;