@lanonasis/cli 1.5.0 → 1.5.2

package/dist/commands/auth.d.ts

@@ -1,6 +1,8 @@
 interface LoginOptions {
     email?: string;
     password?: string;
+    vendorKey?: string;
+    useWebAuth?: boolean;
 }
 export declare function loginCommand(options: LoginOptions): Promise<void>;
 export {};

package/dist/commands/auth.js

@@ -1,41 +1,152 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
-import { createServer } from 'http';
-import { URL } from 'url';
 import open from 'open';
 import { apiClient } from '../utils/api.js';
 import { CLIConfig } from '../utils/config.js';
+// Color scheme
+const colors = {
+    primary: chalk.blue.bold,
+    success: chalk.green,
+    warning: chalk.yellow,
+    error: chalk.red,
+    info: chalk.cyan,
+    accent: chalk.magenta,
+    muted: chalk.gray,
+    highlight: chalk.white.bold
+};
 export async function loginCommand(options) {
     const config = new CLIConfig();
     await config.init();
-    console.log(chalk.blue.bold('🔐 Login to Lanonasis Core Gateway'));
+    console.log(chalk.blue.bold('🔐 Onasis-Core Golden Contract Authentication'));
+    console.log(colors.info('━'.repeat(50)));
     console.log();
-    // Check if API key is provided via environment or option
-    const apiKey = process.env.LANONASIS_API_KEY;
-    if (apiKey) {
-        console.log(chalk.green('✓ Using API key authentication'));
-        await config.setApiKey(apiKey);
-        console.log(chalk.green('✓ Authentication configured successfully'));
+    // Enhanced authentication flow - check for vendor key first
+    if (options.vendorKey) {
+        await handleVendorKeyAuth(options.vendorKey, config);
         return;
     }
-    // Choose authentication method
-    const authMethod = await inquirer.prompt([
+    // Show authentication options
+    const authChoice = await inquirer.prompt([
         {
             type: 'list',
             name: 'method',
             message: 'Choose authentication method:',
             choices: [
-                { name: '🔑 Username/Password (direct login)', value: 'password' },
-                { name: '🌐 Web Browser (OAuth providers)', value: 'oauth' }
+                {
+                    name: '🔑 Vendor Key (Recommended for API access)',
+                    value: 'vendor'
+                },
+                {
+                    name: '🌐 Web OAuth (Browser-based)',
+                    value: 'oauth'
+                },
+                {
+                    name: '⚙️  Username/Password (Direct credentials)',
+                    value: 'credentials'
+                }
             ]
         }
     ]);
-    if (authMethod.method === 'oauth') {
-        await oauthLoginFlow(config);
+    switch (authChoice.method) {
+        case 'vendor':
+            await handleVendorKeyFlow(config);
+            break;
+        case 'oauth':
+            await handleOAuthFlow(config);
+            break;
+        case 'credentials':
+            await handleCredentialsFlow(options, config);
+            break;
+    }
+}
+async function handleVendorKeyAuth(vendorKey, config) {
+    const spinner = ora('Validating vendor key...').start();
+    try {
+        await config.setVendorKey(vendorKey);
+        // Test the vendor key with a health check
+        const response = await apiClient.get('/health');
+        spinner.succeed('Vendor key authentication successful');
+        console.log();
+        console.log(chalk.green('✓ Authenticated with vendor key'));
+        console.log(colors.info('Ready to use Onasis-Core services'));
+    }
+    catch (error) {
+        spinner.fail('Vendor key validation failed');
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red('✖ Invalid vendor key:'), errorMessage);
+        process.exit(1);
+    }
+}
+async function handleVendorKeyFlow(config) {
+    console.log();
+    console.log(chalk.yellow('🔑 Vendor Key Authentication'));
+    console.log(chalk.gray('Vendor keys provide secure API access with format: pk_xxx.sk_xxx'));
+    console.log();
+    const { vendorKey } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'vendorKey',
+            message: 'Enter your vendor key (pk_xxx.sk_xxx):',
+            mask: '*',
+            validate: (input) => {
+                if (!input)
+                    return 'Vendor key is required';
+                if (!input.match(/^pk_[a-zA-Z0-9]+\.sk_[a-zA-Z0-9]+$/)) {
+                    return 'Invalid format. Expected: pk_xxx.sk_xxx';
+                }
+                return true;
+            }
+        }
+    ]);
+    await handleVendorKeyAuth(vendorKey, config);
+}
+async function handleOAuthFlow(config) {
+    console.log();
+    console.log(chalk.yellow('🌐 Web OAuth Authentication'));
+    console.log(chalk.gray('This will open your browser for secure authentication'));
+    console.log();
+    const { proceed } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'proceed',
+            message: 'Open browser for authentication?',
+            default: true
+        }
+    ]);
+    if (!proceed) {
+        console.log(chalk.yellow('Authentication cancelled'));
         return;
     }
-    // Password-based login flow
+    const authUrl = `${config.getDiscoveredApiUrl()}/auth/cli-login`;
+    try {
+        console.log(colors.info('Opening browser...'));
+        await open(authUrl);
+        console.log();
+        console.log(colors.info('Please complete authentication in your browser'));
+        console.log(colors.muted(`If browser doesn't open, visit: ${authUrl}`));
+        // TODO: Implement OAuth callback handling or polling mechanism
+        const { token } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'token',
+                message: 'Paste the authentication token from browser:'
+            }
+        ]);
+        if (token) {
+            await config.setToken(token);
+            console.log(chalk.green('✓ OAuth authentication successful'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('✖ Failed to open browser'));
+        console.log(colors.muted(`Please visit manually: ${authUrl}`));
+    }
+}
+async function handleCredentialsFlow(options, config) {
+    console.log();
+    console.log(chalk.yellow('⚙️  Username/Password Authentication'));
+    console.log();
     let { email, password } = options;
     // Get credentials if not provided
     if (!email || !password) {
@@ -159,125 +270,3 @@ async function registerFlow(defaultEmail) {
         process.exit(1);
     }
 }
-async function oauthLoginFlow(config) {
-    console.log(chalk.blue('🌐 OAuth Authentication'));
-    console.log(chalk.gray('This will open your browser for secure authentication'));
-    console.log();
-    const port = 3721; // CLI callback port
-    const redirectUri = `http://localhost:${port}/callback`;
-    const state = Math.random().toString(36).substring(2, 15);
-    // Construct OAuth URL
-    const authUrl = new URL('https://api.lanonasis.com/v1/auth/oauth');
-    authUrl.searchParams.set('redirect_uri', redirectUri);
-    authUrl.searchParams.set('state', state);
-    authUrl.searchParams.set('project_scope', 'maas');
-    authUrl.searchParams.set('response_type', 'code');
-    const spinner = ora('Starting OAuth flow...').start();
-    try {
-        // Start local callback server
-        const server = createServer();
-        let authCode = null;
-        let authError = null;
-        server.on('request', (req, res) => {
-            const url = new URL(req.url, `http://localhost:${port}`);
-            if (url.pathname === '/callback') {
-                const code = url.searchParams.get('code');
-                const error = url.searchParams.get('error');
-                const returnedState = url.searchParams.get('state');
-                // Validate state parameter
-                if (returnedState !== state) {
-                    authError = 'Invalid state parameter';
-                    res.writeHead(400, { 'Content-Type': 'text/html' });
-                    res.end('<h1>Authentication Failed</h1><p>Invalid state parameter</p>');
-                    return;
-                }
-                if (error) {
-                    authError = url.searchParams.get('error_description') || error;
-                    res.writeHead(400, { 'Content-Type': 'text/html' });
-                    res.end(`<h1>Authentication Failed</h1><p>${authError}</p>`);
-                }
-                else if (code) {
-                    authCode = code;
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end('<h1>Authentication Successful</h1><p>You can close this window and return to the CLI.</p>');
-                }
-                else {
-                    authError = 'No authorization code received';
-                    res.writeHead(400, { 'Content-Type': 'text/html' });
-                    res.end('<h1>Authentication Failed</h1><p>No authorization code received</p>');
-                }
-                server.close();
-            }
-        });
-        // Start server
-        await new Promise((resolve, reject) => {
-            server.listen(port, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
-        spinner.text = 'Opening browser for authentication...';
-        // Open browser
-        await open(authUrl.toString());
-        console.log();
-        console.log(chalk.yellow('Browser opened for authentication'));
-        console.log(chalk.gray(`If browser doesn't open, visit: ${authUrl.toString()}`));
-        console.log();
-        spinner.text = 'Waiting for authentication...';
-        // Wait for callback
-        await new Promise((resolve, reject) => {
-            server.on('close', () => {
-                if (authCode)
-                    resolve();
-                else
-                    reject(new Error(authError || 'Authentication failed'));
-            });
-            // Timeout after 5 minutes
-            setTimeout(() => {
-                server.close();
-                reject(new Error('Authentication timeout'));
-            }, 300000);
-        });
-        if (!authCode) {
-            throw new Error(authError || 'No authorization code received');
-        }
-        spinner.text = 'Exchanging authorization code for session...';
-        // Exchange code for session
-        const response = await fetch('https://api.lanonasis.com/v1/auth/callback', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-project-scope': 'maas'
-            },
-            body: JSON.stringify({
-                code: authCode,
-                state: state,
-                project_scope: 'maas'
-            }),
-            credentials: 'include'
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(errorData.error || `HTTP ${response.status}`);
-        }
-        const sessionData = await response.json();
-        // Store session token
-        await config.setToken(sessionData.access_token);
-        spinner.succeed('OAuth authentication successful');
-        console.log();
-        console.log(chalk.green('✓ Authenticated successfully via OAuth'));
-        console.log(`Welcome, ${sessionData.user.email}!`);
-        if (sessionData.user.organization_id) {
-            console.log(`Organization: ${sessionData.user.organization_id}`);
-        }
-        console.log(`Plan: ${sessionData.user.plan || 'free'}`);
-    }
-    catch (error) {
-        spinner.fail('OAuth authentication failed');
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error(chalk.red('✖ OAuth failed:'), errorMessage);
-        process.exit(1);
-    }
-}

package/dist/commands/completion.d.ts

@@ -0,0 +1,33 @@
+export interface CompletionData {
+    commands: Array<{
+        name: string;
+        description: string;
+        aliases?: string[];
+        subcommands?: Array<{
+            name: string;
+            description: string;
+            options?: Array<{
+                name: string;
+                description: string;
+                type: 'string' | 'boolean' | 'number' | 'choice';
+                choices?: string[];
+                required?: boolean;
+            }>;
+        }>;
+    }>;
+    globalOptions: Array<{
+        name: string;
+        description: string;
+        type: 'string' | 'boolean' | 'number' | 'choice';
+        choices?: string[];
+    }>;
+    contextualData: {
+        memoryTypes: string[];
+        outputFormats: string[];
+        sortOptions: string[];
+        authMethods: string[];
+    };
+}
+export declare function generateCompletionData(): Promise<CompletionData>;
+export declare function completionCommand(): Promise<void>;
+export declare function installCompletionsCommand(): Promise<void>;