berget 1.0.0 → 1.1.0

package/dist/src/commands/auth.js

@@ -0,0 +1,65 @@
+"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.registerAuthCommands = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const auth_service_1 = require("../services/auth-service");
+const client_1 = require("../client");
+const error_handler_1 = require("../utils/error-handler");
+/**
+ * Register authentication commands
+ */
+function registerAuthCommands(program) {
+    const auth = program
+        .command(auth_service_1.AuthService.COMMAND_GROUP)
+        .description('Manage authentication and authorization');
+    auth
+        .command(auth_service_1.AuthService.COMMANDS.LOGIN)
+        .description('Log in to Berget')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        const authService = auth_service_1.AuthService.getInstance();
+        yield authService.login();
+    }));
+    auth
+        .command(auth_service_1.AuthService.COMMANDS.LOGOUT)
+        .description('Log out from Berget')
+        .action(() => {
+        (0, client_1.clearAuthToken)();
+        console.log(chalk_1.default.green('You have been logged out from Berget'));
+    });
+    auth
+        .command(auth_service_1.AuthService.COMMANDS.WHOAMI)
+        .description('Show information about the logged in user')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const authService = auth_service_1.AuthService.getInstance();
+            const profile = yield authService.whoami();
+            if (profile) {
+                console.log(chalk_1.default.bold(`Logged in as: ${profile.name || profile.login}`));
+                console.log(`Email: ${chalk_1.default.cyan(profile.email || 'Not available')}`);
+                console.log(`Role: ${chalk_1.default.cyan(profile.role || 'Not available')}`);
+                if (profile.company) {
+                    console.log(`Company: ${chalk_1.default.cyan(profile.company.name)}`);
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow('You are not logged in. Use `berget login` to log in.'));
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('You are not logged in or an error occurred', error);
+        }
+    }));
+}
+exports.registerAuthCommands = registerAuthCommands;

package/dist/src/commands/autocomplete.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAutocompleteCommands = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Register autocomplete commands
+ */
+function registerAutocompleteCommands(program) {
+    const autocomplete = program
+        .command('autocomplete')
+        .command('install')
+        .description('Install shell autocompletion')
+        .action(() => {
+        console.log(chalk_1.default.green('✓ Berget autocomplete installed in your shell'));
+        console.log(chalk_1.default.green('✓ Shell completion for kubectl also installed'));
+        console.log('');
+        console.log('Restart your shell or run:');
+        console.log('  source ~/.bashrc');
+    });
+}
+exports.registerAutocompleteCommands = registerAutocompleteCommands;

package/dist/src/commands/billing.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBillingCommands = void 0;
+const command_structure_1 = require("../constants/command-structure");
+const client_1 = require("../client");
+const error_handler_1 = require("../utils/error-handler");
+/**
+ * Register billing commands
+ */
+function registerBillingCommands(program) {
+    const billing = program
+        .command(command_structure_1.COMMAND_GROUPS.BILLING)
+        .description('Manage billing and usage');
+    billing
+        .command(command_structure_1.SUBCOMMANDS.BILLING.GET_USAGE)
+        .description('Get token usage statistics')
+        .option('--model <modelId>', 'Get usage for a specific model')
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = (0, client_1.createAuthenticatedClient)();
+            let response;
+            if (options.model) {
+                const { data, error } = yield client.GET('/v1/usage/tokens/{modelId}', {
+                    params: { path: { modelId: options.model } },
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                response = data;
+            }
+            else {
+                const { data, error } = yield client.GET('/v1/usage/tokens');
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                response = data;
+            }
+            console.log('Token Usage:');
+            console.log(JSON.stringify(response, null, 2));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to get token usage', error);
+        }
+    }));
+}
+exports.registerBillingCommands = registerBillingCommands;

package/dist/src/commands/chat.js

@@ -0,0 +1,276 @@
+"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.registerChatCommands = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = __importDefault(require("readline"));
+const command_structure_1 = require("../constants/command-structure");
+const chat_service_1 = require("../services/chat-service");
+const api_key_service_1 = require("../services/api-key-service");
+const auth_service_1 = require("../services/auth-service");
+const error_handler_1 = require("../utils/error-handler");
+const default_api_key_1 = require("../utils/default-api-key");
+/**
+ * Helper function to get user confirmation
+ */
+function confirm(question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+        });
+    });
+}
+/**
+ * Register chat commands
+ */
+function registerChatCommands(program) {
+    const chat = program
+        .command(command_structure_1.COMMAND_GROUPS.CHAT)
+        .description('Interact with AI chat models');
+    chat
+        .command(command_structure_1.SUBCOMMANDS.CHAT.RUN)
+        .description('Run a chat session with a specified model')
+        .argument('[model]', 'Model to use (default: berget-70b-instruct)')
+        .option('-s, --system <message>', 'System message')
+        .option('-t, --temperature <temp>', 'Temperature (0-1)', parseFloat)
+        .option('-m, --max-tokens <tokens>', 'Maximum tokens to generate', parseInt)
+        .option('-k, --api-key <key>', 'API key to use for this chat session')
+        .option('--api-key-id <id>', 'ID of the API key to use from your saved keys')
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const chatService = chat_service_1.ChatService.getInstance();
+            // Check if we have an API key or need to get one
+            let apiKey = options.apiKey;
+            let apiKeyId = options.apiKeyId;
+            // If no API key or API key ID provided, check for default API key
+            if (!apiKey && !apiKeyId) {
+                const defaultApiKeyManager = default_api_key_1.DefaultApiKeyManager.getInstance();
+                const defaultApiKey = defaultApiKeyManager.getDefaultApiKey();
+                if (defaultApiKey) {
+                    apiKeyId = defaultApiKey.id;
+                    console.log(chalk_1.default.dim(`Using default API key: ${defaultApiKey.name}`));
+                }
+            }
+            // If no direct API key, try to get one from API key ID
+            if (!apiKey && apiKeyId) {
+                try {
+                    const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+                    const keys = yield apiKeyService.list();
+                    const selectedKey = keys.find((key) => key.id.toString() === options.apiKeyId);
+                    if (!selectedKey) {
+                        console.log(chalk_1.default.yellow(`API key with ID ${options.apiKeyId} not found. Using default authentication.`));
+                    }
+                    else {
+                        console.log(chalk_1.default.dim(`Using API key: ${selectedKey.name}`));
+                        // We need to rotate the key to get the actual key value
+                        if (yield confirm(chalk_1.default.yellow(`To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`))) {
+                            const rotatedKey = yield apiKeyService.rotate(options.apiKeyId);
+                            apiKey = rotatedKey.key;
+                            console.log(chalk_1.default.green(`API key "${selectedKey.name}" rotated successfully.`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('Using default authentication instead.'));
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Error fetching API key:'));
+                    console.error(error);
+                    console.log(chalk_1.default.yellow('Using default authentication instead.'));
+                }
+            }
+            // Verify we have authentication before starting chat
+            if (!apiKey) {
+                try {
+                    auth_service_1.AuthService.getInstance();
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red('Error: Authentication required for chat'));
+                    console.log(chalk_1.default.yellow('Please either:'));
+                    console.log(chalk_1.default.yellow('1. Log in with `berget auth login`'));
+                    console.log(chalk_1.default.yellow('2. Provide an API key with `--api-key`'));
+                    console.log(chalk_1.default.yellow('3. Provide an API key ID with `--api-key-id`'));
+                    console.log(chalk_1.default.yellow('4. Set a default API key with `berget api-keys set-default <id>`'));
+                    return;
+                }
+            }
+            // Set up readline interface for user input
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            // Prepare messages array
+            const messages = [];
+            // Add system message if provided
+            if (options.system) {
+                messages.push({
+                    role: 'system',
+                    content: options.system,
+                });
+            }
+            console.log(chalk_1.default.cyan('Chat with Berget AI (type "exit" to quit)'));
+            console.log(chalk_1.default.cyan('----------------------------------------'));
+            // Start the conversation loop
+            const askQuestion = () => {
+                rl.question(chalk_1.default.green('You: '), (input) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    // Check if user wants to exit
+                    if (input.toLowerCase() === 'exit') {
+                        console.log(chalk_1.default.cyan('Goodbye!'));
+                        rl.close();
+                        return;
+                    }
+                    // Add user message
+                    messages.push({
+                        role: 'user',
+                        content: input,
+                    });
+                    try {
+                        // Call the API
+                        const response = yield chatService.createCompletion({
+                            model: ((_a = options.args) === null || _a === void 0 ? void 0 : _a[0]) || 'berget-70b-instruct',
+                            messages: messages,
+                            temperature: options.temperature !== undefined ? options.temperature : 0.7,
+                            max_tokens: options.maxTokens || 4096,
+                            apiKey: apiKey,
+                        });
+                        // Debug output
+                        if (program.opts().debug) {
+                            console.log(chalk_1.default.yellow('DEBUG: Full response:'));
+                            console.log(chalk_1.default.yellow(JSON.stringify(response, null, 2)));
+                        }
+                        // Check if response has the expected structure
+                        if (!response ||
+                            !response.choices ||
+                            !response.choices[0] ||
+                            !response.choices[0].message) {
+                            console.error(chalk_1.default.red('Error: Unexpected response format from API'));
+                            console.error(chalk_1.default.red('Response:', JSON.stringify(response, null, 2)));
+                            throw new Error('Unexpected response format from API');
+                        }
+                        // Get assistant's response
+                        const assistantMessage = response.choices[0].message.content;
+                        // Add to messages array
+                        messages.push({
+                            role: 'assistant',
+                            content: assistantMessage,
+                        });
+                        // Display the response
+                        console.log(chalk_1.default.blue('Assistant: ') + assistantMessage);
+                        console.log(); // Empty line for better readability
+                        // Continue the conversation
+                        askQuestion();
+                    }
+                    catch (error) {
+                        console.error(chalk_1.default.red('Error: Failed to get response'));
+                        if (error instanceof Error) {
+                            console.error(chalk_1.default.red(error.message));
+                        }
+                        // Continue despite error
+                        askQuestion();
+                    }
+                }));
+            };
+            // Start the conversation
+            askQuestion();
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to create chat completion', error);
+        }
+    }));
+    chat
+        .command(command_structure_1.SUBCOMMANDS.CHAT.LIST)
+        .description('List available chat models')
+        .option('-k, --api-key <key>', 'API key to use for this request')
+        .option('--api-key-id <id>', 'ID of the API key to use from your saved keys')
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            // If API key ID is provided, fetch the actual key
+            let apiKey = options.apiKey;
+            let apiKeyId = options.apiKeyId;
+            // If no API key or API key ID provided, check for default API key
+            if (!apiKey && !apiKeyId) {
+                const defaultApiKeyManager = default_api_key_1.DefaultApiKeyManager.getInstance();
+                const defaultApiKey = defaultApiKeyManager.getDefaultApiKey();
+                if (defaultApiKey) {
+                    apiKeyId = defaultApiKey.id;
+                    console.log(chalk_1.default.dim(`Using default API key: ${defaultApiKey.name}`));
+                }
+            }
+            if (apiKeyId && !apiKey) {
+                try {
+                    const apiKeyService = api_key_service_1.ApiKeyService.getInstance();
+                    const keys = yield apiKeyService.list();
+                    const selectedKey = keys.find((key) => key.id.toString() === options.apiKeyId);
+                    if (!selectedKey) {
+                        console.log(chalk_1.default.yellow(`API key with ID ${options.apiKeyId} not found. Using default authentication.`));
+                    }
+                    else {
+                        console.log(chalk_1.default.dim(`Using API key: ${selectedKey.name}`));
+                        // We need to rotate the key to get the actual key value
+                        if (yield confirm(chalk_1.default.yellow(`To use API key "${selectedKey.name}", it needs to be rotated. This will invalidate the current key. Continue? (y/n)`))) {
+                            const rotatedKey = yield apiKeyService.rotate(options.apiKeyId);
+                            apiKey = rotatedKey.key;
+                            console.log(chalk_1.default.green(`API key "${selectedKey.name}" rotated successfully.`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('Using default authentication instead.'));
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Error fetching API key:'));
+                    console.error(error);
+                    console.log(chalk_1.default.yellow('Using default authentication instead.'));
+                }
+            }
+            const chatService = chat_service_1.ChatService.getInstance();
+            const models = yield chatService.listModels(apiKey);
+            // Debug output
+            if (program.opts().debug) {
+                console.log(chalk_1.default.yellow('DEBUG: Models response:'));
+                console.log(chalk_1.default.yellow(JSON.stringify(models, null, 2)));
+            }
+            console.log(chalk_1.default.bold('Available Chat Models:'));
+            console.log(chalk_1.default.dim('─'.repeat(70)));
+            console.log(chalk_1.default.dim('MODEL ID'.padEnd(30)) +
+                chalk_1.default.dim('OWNER'.padEnd(25)) +
+                chalk_1.default.dim('CAPABILITIES'));
+            console.log(chalk_1.default.dim('─'.repeat(70)));
+            models.data.forEach((model) => {
+                const capabilities = [];
+                if (model.capabilities.vision)
+                    capabilities.push('vision');
+                if (model.capabilities.function_calling)
+                    capabilities.push('function_calling');
+                if (model.capabilities.json_mode)
+                    capabilities.push('json_mode');
+                console.log(model.id.padEnd(30) +
+                    model.owned_by.padEnd(25) +
+                    capabilities.join(', '));
+            });
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to list chat models', error);
+        }
+    }));
+}
+exports.registerChatCommands = registerChatCommands;

package/dist/src/commands/clusters.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerClusterCommands = void 0;
+const cluster_service_1 = require("../services/cluster-service");
+const error_handler_1 = require("../utils/error-handler");
+/**
+ * Register cluster commands
+ */
+function registerClusterCommands(program) {
+    const cluster = program
+        .command(cluster_service_1.ClusterService.COMMAND_GROUP)
+        .description('Manage Berget clusters');
+    cluster
+        .command(cluster_service_1.ClusterService.COMMANDS.LIST)
+        .description('List all Berget clusters')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const clusterService = cluster_service_1.ClusterService.getInstance();
+            const clusters = yield clusterService.list();
+            console.log('NAME                   STATUS    NODES    CREATED');
+            clusters.forEach((cluster) => {
+                console.log(`${cluster.name.padEnd(22)} ${cluster.status.padEnd(9)} ${String(cluster.nodes).padEnd(8)} ${cluster.created}`);
+            });
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to list clusters', error);
+        }
+    }));
+    cluster
+        .command(cluster_service_1.ClusterService.COMMANDS.GET_USAGE)
+        .description('Get usage metrics for a specific cluster')
+        .argument('<clusterId>', 'Cluster ID')
+        .action((clusterId) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const clusterService = cluster_service_1.ClusterService.getInstance();
+            const usage = yield clusterService.getUsage(clusterId);
+            console.log('Cluster Usage:');
+            console.log(JSON.stringify(usage, null, 2));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to get cluster usage', error);
+        }
+    }));
+    cluster
+        .command(cluster_service_1.ClusterService.COMMANDS.DESCRIBE)
+        .description('Get detailed information about a cluster')
+        .argument('<clusterId>', 'Cluster ID')
+        .action((clusterId) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const clusterService = cluster_service_1.ClusterService.getInstance();
+            const clusterInfo = yield clusterService.describe(clusterId);
+            console.log('Cluster Details:');
+            console.log(JSON.stringify(clusterInfo, null, 2));
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to describe cluster', error);
+        }
+    }));
+}
+exports.registerClusterCommands = registerClusterCommands;

package/dist/src/commands/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = void 0;
+const auth_1 = require("./auth");
+const api_keys_1 = require("./api-keys");
+const clusters_1 = require("./clusters");
+const billing_1 = require("./billing");
+const models_1 = require("./models");
+const users_1 = require("./users");
+const chat_1 = require("./chat");
+const autocomplete_1 = require("./autocomplete");
+/**
+ * Register all command groups with the program
+ */
+function registerCommands(program) {
+    (0, auth_1.registerAuthCommands)(program);
+    (0, api_keys_1.registerApiKeyCommands)(program);
+    (0, clusters_1.registerClusterCommands)(program);
+    (0, billing_1.registerBillingCommands)(program);
+    (0, models_1.registerModelCommands)(program);
+    (0, users_1.registerUserCommands)(program);
+    (0, chat_1.registerChatCommands)(program);
+    (0, autocomplete_1.registerAutocompleteCommands)(program);
+}
+exports.registerCommands = registerCommands;

package/dist/src/commands/models.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModelCommands = void 0;
+const command_structure_1 = require("../constants/command-structure");
+const client_1 = require("../client");
+const error_handler_1 = require("../utils/error-handler");
+/**
+ * Register models commands
+ */
+function registerModelCommands(program) {
+    const models = program
+        .command(command_structure_1.COMMAND_GROUPS.MODELS)
+        .description('Manage AI models');
+    models
+        .command(command_structure_1.SUBCOMMANDS.MODELS.LIST)
+        .description('List available AI models')
+        .option('--id <modelId>', 'Get details for a specific model')
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = (0, client_1.createAuthenticatedClient)();
+            let response;
+            if (options.id) {
+                const { data, error } = yield client.GET('/v1/models/{modelId}', {
+                    params: { path: { modelId: options.id } },
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                response = data;
+                console.log('Model Details:');
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                const { data, error } = yield client.GET('/v1/models');
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                response = data;
+                console.log('Available Models:');
+                console.log('ID                      OWNED BY                  CAPABILITIES');
+                // Ensure response has the expected structure
+                const modelData = response;
+                if (modelData.data) {
+                    modelData.data.forEach((model) => {
+                        const capabilities = [];
+                        if (model.capabilities.vision)
+                            capabilities.push('vision');
+                        if (model.capabilities.function_calling)
+                            capabilities.push('function_calling');
+                        if (model.capabilities.json_mode)
+                            capabilities.push('json_mode');
+                        console.log(`${model.id.padEnd(24)} ${model.owned_by.padEnd(25)} ${capabilities.join(', ')}`);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to get models', error);
+        }
+    }));
+}
+exports.registerModelCommands = registerModelCommands;

package/dist/src/commands/users.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUserCommands = void 0;
+const command_structure_1 = require("../constants/command-structure");
+const client_1 = require("../client");
+const error_handler_1 = require("../utils/error-handler");
+/**
+ * Register user commands
+ */
+function registerUserCommands(program) {
+    const users = program
+        .command(command_structure_1.COMMAND_GROUPS.USERS)
+        .description('Manage users');
+    users
+        .command(command_structure_1.SUBCOMMANDS.USERS.LIST)
+        .description('List team members')
+        .action(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = (0, client_1.createAuthenticatedClient)();
+            const { data, error } = yield client.GET('/v1/users');
+            if (error)
+                throw new Error(JSON.stringify(error));
+            console.log('Team Members:');
+            console.log('NAME                     EMAIL                           ROLE');
+            data.forEach((user) => {
+                console.log(`${user.name.padEnd(24)} ${user.email.padEnd(30)} ${user.role}`);
+            });
+        }
+        catch (error) {
+            (0, error_handler_1.handleError)('Failed to list team members', error);
+        }
+    }));
+}
+exports.registerUserCommands = registerUserCommands;