langmart-gateway-type3 3.0.44 → 3.0.46

package/dist/cli.js

@@ -0,0 +1,792 @@
+"use strict";
+// File: gateway-type3/cli.ts
+// CLI Client for Gateway Type 3 Management
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const local_vault_1 = require("./local-vault");
+const MANAGEMENT_URL = process.env.MANAGEMENT_URL || 'http://localhost:8083';
+const REGISTRY_URL = process.env.REGISTRY_API_URL || 'http://localhost:8081';
+// Initialize vault to check for stored auth key
+const vault = new local_vault_1.LocalVault({
+    vaultPath: process.env.VAULT_PATH,
+    masterPassword: process.env.VAULT_PASSWORD
+});
+// Auto-load API key from vault if not in environment
+let API_KEY = process.env.GATEWAY_API_KEY || '';
+if (!API_KEY && vault.hasAuthKey()) {
+    API_KEY = vault.getAuthKey() || '';
+    if (API_KEY) {
+        console.log('🔐 Using stored authentication key from vault');
+    }
+}
+/**
+ * Helper function to resolve connection identifier to UUID
+ * Accepts either:
+ * - Sequence number (1, 2, 3...) - maps to connection sorted by created_at
+ * - UUID - returns as-is
+ */
+async function resolveConnectionId(input) {
+    // If input is a UUID format, return as-is
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input)) {
+        return input;
+    }
+    // Otherwise treat as sequence number
+    const index = parseInt(input);
+    if (isNaN(index) || index < 1) {
+        throw new Error('Invalid connection identifier. Use sequence number (1, 2, 3...) or UUID');
+    }
+    // Fetch connections sorted by created_at
+    const response = await axios_1.default.get(`${REGISTRY_URL}/api/connections`, {
+        headers: { 'Authorization': `Bearer ${API_KEY}` }
+    });
+    // Sort by created_at (oldest first)
+    const sorted = response.data.connections.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+    if (index > sorted.length) {
+        throw new Error(`Connection #${index} not found. You have ${sorted.length} connection(s)`);
+    }
+    return sorted[index - 1].id;
+}
+const commands = [
+    {
+        name: 'status',
+        description: 'Get gateway running status',
+        handler: async (args) => {
+            try {
+                const response = await axios_1.default.get(`${MANAGEMENT_URL}/status`);
+                console.log('\n📊 Gateway Status:');
+                console.log('─'.repeat(60));
+                console.log(`Status:                 ${response.data.status}`);
+                console.log(`Version:                ${response.data.version}`);
+                console.log(`Instance ID:            ${response.data.instance_id}`);
+                console.log(`Uptime:                 ${response.data.uptime_human}`);
+                console.log(`Registry Connected:  ${response.data.registry_connected ? '✅ Yes' : '❌ No'}`);
+                console.log(`Registry Auth:       ${response.data.registry_authenticated ? '✅ Yes' : '❌ No'}`);
+                console.log('\n📈 Metrics:');
+                console.log(`  Requests Handled:     ${response.data.metrics.requests_handled}`);
+                console.log(`  Requests Active:      ${response.data.metrics.requests_active}`);
+                console.log(`  Error Count:          ${response.data.metrics.error_count}`);
+                console.log(`  Avg Latency:          ${response.data.metrics.avg_latency_ms.toFixed(2)}ms`);
+                console.log('\n🔐 Local Vault Credentials:');
+                console.log(`  Total Stored:         ${response.data.credentials.connections_count}`);
+                if (response.data.credentials.connections_count > 0) {
+                    console.log(`  Use "npm run cli providers" for details`);
+                }
+                console.log('─'.repeat(60));
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'shutdown',
+        description: 'Gracefully shutdown the gateway',
+        handler: async (args) => {
+            try {
+                const response = await axios_1.default.post(`${MANAGEMENT_URL}/shutdown`);
+                console.log('✅', response.data.message);
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'vault',
+        description: 'List credentials in local vault',
+        handler: async (args) => {
+            try {
+                // Get vault providers (connection_ids with credentials)
+                const vaultResponse = await axios_1.default.get(`${MANAGEMENT_URL}/providers`);
+                if (vaultResponse.data.providers.length === 0) {
+                    console.log('\n🔌 Local Vault Providers:');
+                    console.log('─'.repeat(80));
+                    console.log('  No credentials stored in local vault');
+                    console.log('  Use "npm run cli add-provider <#> <api-key>" to add credentials');
+                    console.log('─'.repeat(80));
+                    return;
+                }
+                // Fetch connection details from registry if API key available
+                let connectionsMap = new Map();
+                if (API_KEY) {
+                    try {
+                        const connectionsResponse = await axios_1.default.get(`${REGISTRY_URL}/api/connections`, {
+                            headers: { 'Authorization': `Bearer ${API_KEY}` }
+                        });
+                        // Sort by created_at to match sequence numbering
+                        const sorted = connectionsResponse.data.connections.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+                        sorted.forEach((conn, index) => {
+                            connectionsMap.set(conn.id, { ...conn, sequence: index + 1 });
+                        });
+                    }
+                    catch (e) {
+                        // Registry not available, show limited info
+                    }
+                }
+                console.log('\n🔌 Local Vault Providers:');
+                console.log('─'.repeat(80));
+                vaultResponse.data.providers.forEach((provider) => {
+                    const connDetails = connectionsMap.get(provider.connection_id);
+                    if (connDetails) {
+                        console.log(`#${connDetails.sequence} - ${connDetails.access_key}`);
+                        console.log(`   Provider:     ${connDetails.provider.name} (${connDetails.provider.key})`);
+                        console.log(`   Endpoint:     ${connDetails.endpoint_url}`);
+                        console.log(`   Gateway Mode: self-hosted (local vault)`);
+                        console.log(`   Credential:   ✅ Stored in vault`);
+                    }
+                    else {
+                        console.log(`   ${provider.connection_id}`);
+                        console.log(`   Credential:   ✅ Stored in vault`);
+                        console.log(`   (Run "npm run cli connections" for full details)`);
+                    }
+                    console.log('');
+                });
+                console.log(`Total: ${vaultResponse.data.providers.length} credential(s) in local vault`);
+                console.log('─'.repeat(80));
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'add-provider',
+        description: 'Add a provider credential (Usage: add-provider <#|connection_id> <api_key> [provider_name] [description])',
+        handler: async (args) => {
+            if (args.length < 2) {
+                console.error('❌ Usage: add-provider <#|connection_id> <api_key> [provider_name] [description]');
+                console.error('   #: Connection sequence number from connections (e.g., 1, 2, 3)');
+                console.error('   connection_id: UUID of the connection');
+                process.exit(1);
+            }
+            const [connection_input, api_key, provider_name, description] = args;
+            try {
+                const connection_id = await resolveConnectionId(connection_input);
+                const response = await axios_1.default.post(`${MANAGEMENT_URL}/providers`, {
+                    connection_id,
+                    api_key,
+                    provider_name,
+                    description
+                });
+                console.log('✅', response.data.message);
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'update-provider',
+        description: 'Update a provider credential API key (Usage: update-provider <#|connection_id> <new_api_key>)',
+        handler: async (args) => {
+            if (args.length < 2) {
+                console.error('❌ Usage: update-provider <#|connection_id> <new_api_key>');
+                console.error('   #: Connection sequence number from connections (e.g., 1, 2, 3)');
+                process.exit(1);
+            }
+            const [connection_input, api_key] = args;
+            try {
+                const connection_id = await resolveConnectionId(connection_input);
+                // Remove old credential
+                await axios_1.default.delete(`${MANAGEMENT_URL}/providers/${connection_id}`);
+                // Add new credential
+                const response = await axios_1.default.post(`${MANAGEMENT_URL}/providers`, {
+                    connection_id,
+                    api_key
+                });
+                console.log('✅', response.data.message);
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'remove-provider',
+        description: 'Remove a provider credential (Usage: remove-provider <#|connection_id>)',
+        handler: async (args) => {
+            if (args.length < 1) {
+                console.error('❌ Usage: remove-provider <#|connection_id>');
+                console.error('   #: Connection sequence number from connections (e.g., 1, 2, 3)');
+                process.exit(1);
+            }
+            const [connection_input] = args;
+            try {
+                const connection_id = await resolveConnectionId(connection_input);
+                const response = await axios_1.default.delete(`${MANAGEMENT_URL}/providers/${connection_id}`);
+                console.log('✅', response.data.message);
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'auth',
+        description: 'Authenticate with registry and save API key (Usage: auth <api_key>)',
+        handler: async (args) => {
+            if (args.length < 1) {
+                console.error('❌ Usage: auth <api_key>');
+                process.exit(1);
+            }
+            const [api_key] = args;
+            try {
+                // Test the API key by making a request to the registry
+                console.log('🔑 Testing API key with registry...');
+                const testResponse = await axios_1.default.get(`${REGISTRY_URL}/api/connections`, {
+                    headers: { 'Authorization': `Bearer ${api_key}` }
+                });
+                // If we got here, the key is valid
+                console.log('✅ API key is valid');
+                // Save to vault for future use
+                await vault.setAuthKey(api_key);
+                console.log('✅ API key saved to vault');
+                console.log('ℹ️  You can now run CLI commands without setting GATEWAY_API_KEY');
+                // Update gateway's auth key via management API
+                try {
+                    const response = await axios_1.default.post(`${MANAGEMENT_URL}/auth`, { api_key });
+                    console.log('✅', response.data.message);
+                    if (response.data.note) {
+                        console.log('ℹ️ ', response.data.note);
+                    }
+                }
+                catch (mgmtError) {
+                    console.log('⚠️  Gateway not running - key saved to vault only');
+                }
+                // Update the global API_KEY variable
+                API_KEY = api_key;
+            }
+            catch (error) {
+                console.error('❌ Authentication failed:', error.response?.data?.error || error.message);
+                console.error('   API key is invalid or registry is not accessible');
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'reconnect',
+        description: 'Reconnect to registry',
+        handler: async (args) => {
+            try {
+                const response = await axios_1.default.post(`${MANAGEMENT_URL}/reconnect`);
+                console.log('✅', response.data.message);
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'logout',
+        description: 'Clear stored authentication key from vault',
+        handler: async (args) => {
+            try {
+                if (!vault.hasAuthKey()) {
+                    console.log('ℹ️  No authentication key stored in vault');
+                    return;
+                }
+                await vault.removeAuthKey();
+                console.log('✅ Authentication key removed from vault');
+                console.log('ℹ️  You will need to run "auth <api_key>" again to authenticate');
+                // Clear the global API_KEY variable
+                API_KEY = '';
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'health',
+        description: 'Check gateway health',
+        handler: async (args) => {
+            try {
+                const response = await axios_1.default.get(`${MANAGEMENT_URL}/health`);
+                console.log('✅ Gateway is healthy');
+                console.log('   Timestamp:', response.data.timestamp);
+            }
+            catch (error) {
+                console.error('❌ Gateway is unhealthy');
+                console.error('   Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'models',
+        description: 'Discover available models from connections (Usage: models [#|connection_id])',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            try {
+                // Get all connections first
+                const connectionsResponse = await axios_1.default.get(`${REGISTRY_URL}/api/connections`, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                // Sort by created_at to match sequence numbering
+                const sorted = connectionsResponse.data.connections.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+                // Determine which connections to query
+                let connectionsToQuery = sorted;
+                if (args.length > 0) {
+                    // User specified a connection
+                    const connection_id = await resolveConnectionId(args[0]);
+                    connectionsToQuery = sorted.filter((c) => c.id === connection_id);
+                    if (connectionsToQuery.length === 0) {
+                        console.error('❌ Connection not found');
+                        process.exit(1);
+                    }
+                }
+                console.log('\n🤖 Discovering Models...');
+                console.log('─'.repeat(80));
+                // Query models for each connection
+                for (const conn of connectionsToQuery) {
+                    const sequence = sorted.findIndex((c) => c.id === conn.id) + 1;
+                    console.log(`\n#${sequence} - ${conn.access_key}`);
+                    console.log(`Provider: ${conn.provider.name} (${conn.provider.key})`);
+                    console.log(`Endpoint: ${conn.endpoint_url}`);
+                    try {
+                        // Make model discovery request through registry
+                        const modelsResponse = await axios_1.default.post(`${REGISTRY_URL}/api/models/discover`, {
+                            connection_id: conn.id
+                        }, {
+                            headers: {
+                                'Authorization': `Bearer ${API_KEY}`,
+                                'Content-Type': 'application/json'
+                            },
+                            timeout: 30000
+                        });
+                        if (modelsResponse.data.success && modelsResponse.data.models && modelsResponse.data.models.length > 0) {
+                            console.log(`Models: ${modelsResponse.data.models.length} found (${modelsResponse.data.stored} stored)`);
+                            console.log('');
+                            // Show discovered models
+                            modelsResponse.data.models.forEach((model, idx) => {
+                                console.log(`  ${idx + 1}. ${model.id}`);
+                                if (model.name && model.name !== model.id) {
+                                    console.log(`     Name: ${model.name}`);
+                                }
+                                if (model.context_window) {
+                                    console.log(`     Context: ${model.context_window} tokens`);
+                                }
+                                if (model.pricing && (model.pricing.input > 0 || model.pricing.output > 0)) {
+                                    console.log(`     Pricing: $${model.pricing.input}/1K input, $${model.pricing.output}/1K output`);
+                                }
+                            });
+                        }
+                        else {
+                            console.log('Models: None found');
+                        }
+                    }
+                    catch (error) {
+                        if (error.code === 'ECONNABORTED') {
+                            console.log('⚠️  Timeout - endpoint did not respond');
+                        }
+                        else if (error.response?.status === 404) {
+                            console.log('⚠️  Model discovery not supported by this provider');
+                        }
+                        else {
+                            console.log(`⚠️  Error: ${error.response?.data?.error || error.message}`);
+                        }
+                    }
+                }
+                console.log('\n' + '─'.repeat(80));
+                console.log(`💡 Tip: Use "npm run cli models <#>" to query a specific connection`);
+                console.log('');
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'providers',
+        description: 'List available providers from registry',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            try {
+                const response = await axios_1.default.get(`${REGISTRY_URL}/api/public/providers`, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                console.log('\n🌐 Available Providers from Registry:');
+                console.log('─'.repeat(80));
+                if (response.data.providers.length === 0) {
+                    console.log('  No providers available');
+                }
+                else {
+                    response.data.providers.forEach((provider, index) => {
+                        console.log(`${index + 1}. ${provider.name}`);
+                        console.log(`   Provider Key:     ${provider.key}`);
+                        console.log(`   Base URL:         ${provider.base_url || 'N/A'}`);
+                        console.log(`   Your Access Pts:  ${provider.user_connections}`);
+                        console.log('');
+                    });
+                }
+                console.log(`Total: ${response.data.total} providers`);
+                console.log('─'.repeat(80));
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'connections',
+        description: 'List your access points from registry',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            try {
+                const response = await axios_1.default.get(`${REGISTRY_URL}/api/connections`, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                // Sort by created_at (oldest first) to maintain consistent numbering
+                const sorted = response.data.connections.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+                console.log('\n🔌 Your Access Points:');
+                console.log('─'.repeat(80));
+                if (sorted.length === 0) {
+                    console.log('  No access points configured');
+                }
+                else {
+                    sorted.forEach((ap, index) => {
+                        console.log(`#${index + 1} - ${ap.access_key}`);
+                        console.log(`   Provider:     ${ap.provider.name} (${ap.provider.key})`);
+                        console.log(`   Endpoint:     ${ap.endpoint_url}`);
+                        console.log(`   Type:         ${ap.endpoint_type}`);
+                        console.log(`   Gateway Mode: ${ap.gateway_type === 2 ? 'managed' : 'self-hosted'}`);
+                        console.log(`   Rate Limits:  ${ap.rate_limits.rpm} RPM / ${ap.rate_limits.tpm} TPM`);
+                        console.log(`   Status:       ${ap.status}`);
+                        console.log(`   Created:      ${new Date(ap.created_at).toLocaleString()}`);
+                        console.log('');
+                    });
+                    console.log('💡 Tip: Use the # number (e.g., "1") instead of UUID in commands');
+                }
+                console.log(`Total: ${sorted.length} access points`);
+                console.log('─'.repeat(80));
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'add-connection',
+        description: 'Create new access point on registry (Usage: add-connection <provider_key> <endpoint_url> <gateway_mode> [endpoint_type] [api_key])',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            if (args.length < 3) {
+                console.error('❌ Usage: add-connection <provider_key> <endpoint_url> <gateway_mode> [endpoint_type] [api_key]');
+                console.error('   provider_key: ollama, openai, anthropic, groq, etc.');
+                console.error('   endpoint_url: Provider API endpoint URL');
+                console.error('   gateway_mode: managed (registry-managed) or self-hosted (local vault)');
+                console.error('   endpoint_type: (optional, default: openai-v1) openai-v1, anthropic-messages, google-gemini, etc.');
+                console.error('   api_key: Required for managed, optional for self-hosted');
+                process.exit(1);
+            }
+            const [provider_key, endpoint_url, gateway_mode, endpoint_type = 'openai-v1', api_key] = args;
+            // Map gateway_mode to gateway_type number
+            let gateway_type;
+            if (gateway_mode === 'managed') {
+                gateway_type = 2;
+            }
+            else if (gateway_mode === 'self-hosted') {
+                gateway_type = 3;
+            }
+            else {
+                console.error('❌ Invalid gateway_mode. Use "managed" or "self-hosted"');
+                process.exit(1);
+            }
+            try {
+                // First get provider_id from provider_key
+                const providersResponse = await axios_1.default.get(`${REGISTRY_URL}/api/public/providers`, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                const provider = providersResponse.data.providers.find((p) => p.key === provider_key);
+                if (!provider) {
+                    console.error(`❌ Provider key '${provider_key}' not found`);
+                    console.error('   Available providers:');
+                    providersResponse.data.providers.forEach((p) => {
+                        console.error(`     - ${p.key} (${p.name})`);
+                    });
+                    process.exit(1);
+                }
+                const response = await axios_1.default.post(`${REGISTRY_URL}/api/connections`, {
+                    provider_id: provider.id,
+                    endpoint_url,
+                    endpoint_type,
+                    gateway_type: gateway_type,
+                    api_key
+                }, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                console.log('✅', response.data.message);
+                console.log('\n📋 Access Point Details:');
+                console.log('   ID:           ', response.data.connection.id);
+                console.log('   Access Key:   ', response.data.connection.access_key);
+                console.log('   Provider:     ', response.data.connection.provider.name);
+                console.log('   Gateway Mode: ', gateway_type === 2 ? 'managed' : 'self-hosted');
+                console.log('   Status:       ', response.data.connection.status);
+                if (gateway_type === 3 && api_key) {
+                    console.log('\nℹ️  Now adding credential to local vault...');
+                    try {
+                        const vaultResponse = await axios_1.default.post(`${MANAGEMENT_URL}/providers`, {
+                            connection_id: response.data.connection.id,
+                            api_key: api_key,
+                            provider_name: response.data.connection.provider.name
+                        });
+                        console.log('✅', vaultResponse.data.message);
+                    }
+                    catch (vaultError) {
+                        console.error('⚠️  Warning: Failed to add to local vault:', vaultError.response?.data?.error || vaultError.message);
+                        console.error('   You can add it manually using: npm run cli add-provider');
+                    }
+                }
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'switch-to-managed',
+        description: 'Switch access point to managed mode (registry-managed) (Usage: switch-to-managed <#|connection_id> [api_key])',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            if (args.length < 1) {
+                console.error('❌ Usage: switch-to-managed <#|connection_id> [api_key]');
+                console.error('   #: Connection sequence number from connections (e.g., 1, 2, 3)');
+                console.error('   api_key: (optional) The provider API key, will be retrieved from local vault if not provided');
+                process.exit(1);
+            }
+            const [connection_input, provided_api_key] = args;
+            let api_key = provided_api_key;
+            try {
+                const connection_id = await resolveConnectionId(connection_input);
+                // If API key not provided, backend will retrieve it from vault automatically
+                if (!api_key) {
+                    console.log('ℹ️  API key will be retrieved from local vault by backend...');
+                }
+                const response = await axios_1.default.put(`${REGISTRY_URL}/api/connections/${connection_id}`, {
+                    gateway_type: 2,
+                    api_key: api_key || undefined
+                }, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                console.log('✅', response.data.message);
+                console.log('   Access point switched to managed mode (registry-managed)');
+                console.log('   Credential is now stored on registry');
+                console.log('\nℹ️  Removing credential from local vault...');
+                try {
+                    await axios_1.default.delete(`${MANAGEMENT_URL}/providers/${connection_id}`);
+                    console.log('✅ Credential removed from local vault');
+                }
+                catch (vaultError) {
+                    console.error('⚠️  Warning: Failed to remove from local vault:', vaultError.response?.data?.error || vaultError.message);
+                }
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'switch-to-self-hosted',
+        description: 'Switch access point to self-hosted mode (local vault) (Usage: switch-to-self-hosted <#|connection_id> <api_key>)',
+        handler: async (args) => {
+            if (!API_KEY) {
+                console.error('❌ GATEWAY_API_KEY environment variable is required');
+                process.exit(1);
+            }
+            if (args.length < 2) {
+                console.error('❌ Usage: switch-to-self-hosted <#|connection_id> <api_key>');
+                console.error('   #: Connection sequence number from connections (e.g., 1, 2, 3)');
+                console.error('   api_key: The provider API key to store in local vault');
+                process.exit(1);
+            }
+            const [connection_input, api_key] = args;
+            try {
+                const connection_id = await resolveConnectionId(connection_input);
+                const response = await axios_1.default.put(`${REGISTRY_URL}/api/connections/${connection_id}`, {
+                    gateway_type: 3,
+                    api_key
+                }, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` }
+                });
+                console.log('✅', response.data.message);
+                console.log('   Access point switched to self-hosted mode (local vault)');
+                console.log('   Credential removed from registry');
+                console.log('\nℹ️  Adding credential to local vault...');
+                try {
+                    const vaultResponse = await axios_1.default.post(`${MANAGEMENT_URL}/providers`, {
+                        connection_id: connection_id,
+                        api_key: api_key
+                    });
+                    console.log('✅', vaultResponse.data.message);
+                }
+                catch (vaultError) {
+                    console.error('⚠️  Warning: Failed to add to local vault:', vaultError.response?.data?.error || vaultError.message);
+                }
+            }
+            catch (error) {
+                console.error('❌ Error:', error.response?.data?.error || error.message);
+                process.exit(1);
+            }
+        }
+    },
+    {
+        name: 'help',
+        description: 'Show this help message',
+        handler: async (args) => {
+            showHelp();
+        }
+    }
+];
+function showHelp() {
+    console.log('\n');
+    console.log('═'.repeat(80));
+    console.log('🚀  Gateway Type 3 CLI - Self-Hosted Gateway Management');
+    console.log('═'.repeat(80));
+    console.log('\n💡 TIP: Interactive UI Available!');
+    console.log('─'.repeat(80));
+    console.log('  For a better experience, try the interactive UI:');
+    console.log('  npm run ui');
+    console.log('  Features: Visual menus, real-time status, guided workflows');
+    console.log('\n📚 QUICK START - First Time Setup:');
+    console.log('─'.repeat(80));
+    console.log('  1. Authenticate (saves your API key securely):');
+    console.log('     npm run cli auth <your-api-key>');
+    console.log('     Example: npm run cli auth sk-test-inference-key');
+    console.log('');
+    console.log('  2. View your access points (connections):');
+    console.log('     npm run cli connections');
+    console.log('');
+    console.log('  3. Add provider credentials to local vault:');
+    console.log('     npm run cli add-provider <#> <api-key>');
+    console.log('     Example: npm run cli add-provider 1 ollama');
+    console.log('');
+    console.log('  💡 After authentication, you can run ALL commands without setting API key!');
+    console.log('\n🔑 Authentication & Security:');
+    console.log('─'.repeat(80));
+    console.log('  auth <api-key>       Authenticate with registry (saves key to vault)');
+    console.log('  logout               Clear stored authentication key from vault');
+    console.log('  status               Show gateway health and connection status');
+    console.log('  health               Quick health check');
+    console.log('  models [#]           Discover available models (all connections or specific #)');
+    console.log('\n🔌 Access Points (Connections) - View & Manage:');
+    console.log('─'.repeat(80));
+    console.log('  connections          List all your access points with sequence numbers (#1, #2...)');
+    console.log('  providers            List available providers from registry');
+    console.log('  add-connection       Create new access point on registry');
+    console.log('                       Usage: add-connection <provider> <url> <mode> [type] [key]');
+    console.log('                       Example: add-connection ollama http://localhost:11434/v1 self-hosted');
+    console.log('\n🗝️  Provider Credentials - Local Vault Management:');
+    console.log('─'.repeat(80));
+    console.log('  vault                List credentials stored in local vault');
+    console.log('  add-provider         Add credential to vault (use # from connections)');
+    console.log('                       Usage: add-provider <#> <api-key> [name] [description]');
+    console.log('                       Example: add-provider 1 ollama');
+    console.log('  update-provider      Update credential in vault');
+    console.log('                       Usage: update-provider <#> <new-api-key>');
+    console.log('  remove-provider      Remove credential from vault');
+    console.log('                       Usage: remove-provider <#>');
+    console.log('\n🔄 Gateway Mode Switching:');
+    console.log('─'.repeat(80));
+    console.log('  switch-to-managed    Switch to managed mode (registry stores credential)');
+    console.log('                       Usage: switch-to-managed <#> [api-key]');
+    console.log('  switch-to-self-hosted Switch to self-hosted mode (local vault stores credential)');
+    console.log('                       Usage: switch-to-self-hosted <#> <api-key>');
+    console.log('\n⚙️  Gateway Control:');
+    console.log('─'.repeat(80));
+    console.log('  shutdown             Gracefully shutdown the gateway server');
+    console.log('  reconnect            Reconnect gateway to registry');
+    console.log('\n💡 TIPS & TRICKS:');
+    console.log('─'.repeat(80));
+    console.log('  • Use sequence numbers (#1, #2, #3) instead of long UUIDs');
+    console.log('  • Run "connections" to see all your # numbers');
+    console.log('  • "Managed" mode: Registry stores credentials (easier, less private)');
+    console.log('  • "Self-hosted" mode: Local vault stores credentials (more secure, more control)');
+    console.log('  • Authenticate once with "auth" - key saved securely for all future commands');
+    console.log('  • Use "logout" to clear stored authentication when switching accounts');
+    console.log('\n📖 COMMON WORKFLOWS:');
+    console.log('─'.repeat(80));
+    console.log('  First-time setup:');
+    console.log('    npm run cli auth sk-your-api-key');
+    console.log('    npm run cli connections');
+    console.log('    npm run cli add-provider 1 <provider-api-key>');
+    console.log('');
+    console.log('  Check gateway status:');
+    console.log('    npm run cli status');
+    console.log('    npm run cli vault');
+    console.log('');
+    console.log('  Discover available models:');
+    console.log('    npm run cli models                           # All connections');
+    console.log('    npm run cli models 4                         # Specific connection #4');
+    console.log('');
+    console.log('  Manage credentials:');
+    console.log('    npm run cli connections                      # See all access points');
+    console.log('    npm run cli add-provider 2 <api-key>         # Add credential for #2');
+    console.log('    npm run cli update-provider 2 <new-api-key>  # Update credential for #2');
+    console.log('    npm run cli remove-provider 2                 # Remove credential for #2');
+    console.log('');
+    console.log('  Switch modes:');
+    console.log('    npm run cli switch-to-managed 1               # Move to registry');
+    console.log('    npm run cli switch-to-self-hosted 1 <api-key> # Move to local vault');
+    console.log('\n🌐 Environment Variables (Optional):');
+    console.log('─'.repeat(80));
+    console.log('  GATEWAY_API_KEY      Your registry API key (auto-loaded from vault after auth)');
+    console.log('  MANAGEMENT_URL       Gateway management API (default: http://localhost:8083)');
+    console.log('  REGISTRY_API_URL  Registry API URL (default: http://localhost:8081)');
+    console.log('\n');
+    console.log('═'.repeat(80));
+    console.log('📘 For more help, visit: https://github.com/your-repo/docs');
+    console.log('═'.repeat(80));
+    console.log('');
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        showHelp();
+        process.exit(0);
+    }
+    const commandName = args[0];
+    const commandArgs = args.slice(1);
+    const command = commands.find(cmd => cmd.name === commandName);
+    if (!command) {
+        console.error(`❌ Unknown command: ${commandName}`);
+        console.error('   Run "npm run cli help" for available commands');
+        process.exit(1);
+    }
+    await command.handler(commandArgs);
+}
+main().catch((error) => {
+    console.error('❌ Fatal error:', error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map