@lanonasis/cli 1.5.0 → 1.5.1

package/dist/commands/auth.js

@@ -1,41 +1,13 @@
 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';
 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('🔐 Login to MaaS (Supabase Auth)'));
     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'));
-        return;
-    }
-    // Choose authentication method
-    const authMethod = 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' }
-            ]
-        }
-    ]);
-    if (authMethod.method === 'oauth') {
-        await oauthLoginFlow(config);
-        return;
-    }
-    // Password-based login flow
     let { email, password } = options;
     // Get credentials if not provided
     if (!email || !password) {
@@ -159,125 +131,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/mcp.js

@@ -19,10 +19,9 @@ export function mcpCommands(program) {
         const config = new CLIConfig();
         const isAuthenticated = !!config.get('token');
         if (isAuthenticated) {
-            console.log(chalk.green('✓ Authenticated - Using enterprise MCP modes'));
-            console.log('  SSE Mode: api.lanonasis.com (regular users)');
-            console.log('  WebSocket Mode: mcp.lanonasis.com (enterprise users)');
-            console.log('  with real-time updates enabled');
+            console.log(chalk.green('✓ Authenticated - Using remote MCP mode'));
+            console.log('  Your memory operations will use api.lanonasis.com');
+            console.log('  with real-time SSE updates enabled');
         }
         else {
             console.log(chalk.yellow('⚠️  Not authenticated - Using local MCP mode'));
@@ -31,8 +30,7 @@ export function mcpCommands(program) {
         console.log('');
         console.log(chalk.cyan('Available MCP Commands:'));
         console.log('  lanonasis mcp connect       # Auto-connect to best mode');
-        console.log('  lanonasis mcp connect -r    # Force remote SSE mode');
-        console.log('  lanonasis mcp connect -w    # Force WebSocket mode (enterprise)');
+        console.log('  lanonasis mcp connect -r    # Force remote mode');
         console.log('  lanonasis mcp connect -l    # Force local mode');
         console.log('  lanonasis mcp status        # Check connection status');
         console.log('  lanonasis mcp tools         # List available tools');
@@ -50,79 +48,74 @@ export function mcpCommands(program) {
                 spinner.fail('Failed to auto-connect to MCP');
             }
         }
-        catch (_error) {
+        catch {
             spinner.fail('MCP auto-connect failed');
         }
     });
     // Connect command
     mcp.command('connect')
-        .description('Connect to MCP server (local, remote SSE, or WebSocket)')
+        .description('Connect to MCP server (local, remote, or WebSocket)')
         .option('-l, --local', 'Connect to local MCP server')
-        .option('-r, --remote', 'Connect to remote SSE server (api.lanonasis.com)')
-        .option('-w, --websocket', 'Connect to WebSocket server (mcp.lanonasis.com) - Enterprise')
+        .option('-r, --remote', 'Connect to remote MCP server (api.lanonasis.com)')
+        .option('-w, --websocket', 'Connect using WebSocket mode for enterprise users')
         .option('-s, --server <path>', 'Local MCP server path')
-        .option('-u, --url <url>', 'Remote MCP server URL')
+        .option('-u, --url <url>', 'Remote/WebSocket server URL')
         .action(async (options) => {
         const spinner = ora('Connecting to MCP server...').start();
         const config = new CLIConfig();
         try {
-            // Determine connection mode
-            let connectionMode = 'local';
+            let connectionMode;
+            // Determine connection mode - WebSocket takes precedence over remote and local
             if (options.websocket) {
                 connectionMode = 'websocket';
             }
             else if (options.remote) {
                 connectionMode = 'remote';
             }
-            else if (!options.local && !options.remote && !options.websocket) {
-                // Auto-detect: WebSocket for enterprise, SSE for regular, local if not authenticated
-                const token = config.get('token');
-                if (token) {
-                    // Check if enterprise user (simplified check)
-                    connectionMode = 'remote'; // Default to SSE for now
-                }
+            else if (options.local) {
+                connectionMode = 'local';
+            }
+            else {
+                // Default to remote if authenticated, otherwise local
+                connectionMode = !!config.get('token') ? 'remote' : 'local';
             }
-            // Save preference
+            // Save preferences
             config.set('mcpConnectionMode', connectionMode);
             if (options.server) {
                 config.set('mcpServerPath', options.server);
             }
             if (options.url) {
-                config.set('mcpServerUrl', options.url);
+                if (connectionMode === 'websocket') {
+                    config.set('mcpWebSocketUrl', options.url);
+                }
+                else {
+                    config.set('mcpServerUrl', options.url);
+                }
             }
             const client = getMCPClient();
             const connected = await client.connect({
-                mode: connectionMode,
+                connectionMode,
                 serverPath: options.server,
                 serverUrl: options.url
             });
             if (connected) {
-                const modeLabels = {
-                    local: 'local',
-                    remote: 'remote SSE',
-                    websocket: 'WebSocket (Enterprise)'
-                };
-                spinner.succeed(chalk.green(`Connected to ${modeLabels[connectionMode]} MCP server`));
+                spinner.succeed(chalk.green(`Connected to MCP server in ${connectionMode} mode`));
                 if (connectionMode === 'remote') {
                     console.log(chalk.cyan('ℹ️  Using remote MCP via api.lanonasis.com'));
                     console.log(chalk.cyan('📡 SSE endpoint active for real-time updates'));
                 }
                 else if (connectionMode === 'websocket') {
-                    console.log(chalk.cyan('🚀 Using enterprise WebSocket MCP via mcp.lanonasis.com'));
-                    console.log(chalk.cyan('⚡ Real-time WebSocket connection active'));
-                    console.log(chalk.cyan('🏢 Enterprise features enabled'));
+                    console.log(chalk.cyan('ℹ️  Using enterprise WebSocket MCP server'));
+                    console.log(chalk.cyan('📡 WebSocket connection active with auto-reconnect'));
                 }
             }
             else {
                 spinner.fail('Failed to connect to MCP server');
-                if (connectionMode === 'websocket') {
-                    console.log(chalk.yellow('💡 WebSocket mode requires enterprise access'));
-                    console.log(chalk.yellow('   Try: lanonasis mcp connect -r (for SSE mode)'));
-                }
             }
         }
         catch (error) {
             spinner.fail(`Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
         }
     });
     // Disconnect command
@@ -222,7 +215,7 @@ export function mcpCommands(program) {
                 try {
                     args = JSON.parse(options.args);
                 }
-                catch (error) {
+                catch {
                     spinner.fail('Invalid JSON arguments');
                     process.exit(1);
                 }

package/dist/commands/memory.js

@@ -6,8 +6,6 @@ import wrap from 'word-wrap';
 import { format } from 'date-fns';
 import { apiClient } from '../utils/api.js';
 import { formatBytes, truncateText } from '../utils/formatting.js';
-import { output } from '../utils/output.js';
-// Using GetMemoriesParams from api.ts
 export function memoryCommands(program) {
     // Create memory
     program
@@ -23,11 +21,7 @@ export function memoryCommands(program) {
         .action(async (options) => {
         try {
             let { title, content, type, tags, topicId, interactive } = options;
-            // Validate required fields in silent mode
-            if (output.isSilent() && (!title || !content)) {
-                throw new Error('Title and content are required when using --output json or --silent');
-            }
-            if ((interactive || (!title || !content)) && !output.isSilent()) {
+            if (interactive || (!title || !content)) {
                 const answers = await inquirer.prompt([
                     {
                         type: 'input',
@@ -62,7 +56,7 @@ export function memoryCommands(program) {
                 type = answers.type;
                 tags = answers.tags;
             }
-            const spinner = output.isSilent() ? null : ora('Creating memory...').start();
+            const spinner = ora('Creating memory...').start();
             const memoryData = {
                 title,
                 content,
@@ -75,25 +69,19 @@ export function memoryCommands(program) {
                 memoryData.topic_id = topicId;
             }
             const memory = await apiClient.createMemory(memoryData);
-            if (spinner)
-                spinner.succeed('Memory created successfully');
-            if (output.isJsonOutput()) {
-                output.json(memory);
-            }
-            else {
-                console.log();
-                console.log(chalk.green('✓ Memory created:'));
-                console.log(`  ID: ${chalk.cyan(memory.id)}`);
-                console.log(`  Title: ${memory.title}`);
-                console.log(`  Type: ${memory.memory_type}`);
-                if (memory.tags && memory.tags.length > 0) {
-                    console.log(`  Tags: ${memory.tags.join(', ')}`);
-                }
+            spinner.succeed('Memory created successfully');
+            console.log();
+            console.log(chalk.green('✓ Memory created:'));
+            console.log(`  ID: ${chalk.cyan(memory.id)}`);
+            console.log(`  Title: ${memory.title}`);
+            console.log(`  Type: ${memory.memory_type}`);
+            if (memory.tags && memory.tags.length > 0) {
+                console.log(`  Tags: ${memory.tags.join(', ')}`);
             }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            output.error(chalk.red('✖ Failed to create memory:'), errorMessage);
+            console.error(chalk.red('✖ Failed to create memory:'), errorMessage);
             process.exit(1);
         }
     });
@@ -111,41 +99,36 @@ export function memoryCommands(program) {
         .option('--order <order>', 'sort order (asc, desc)', 'desc')
         .action(async (options) => {
         try {
-            const spinner = output.isSilent() ? null : ora('Fetching memories...').start();
+            const spinner = ora('Fetching memories...').start();
             const params = {
-                offset: (parseInt(options.page || '1') - 1) * parseInt(options.limit || '20'),
+                page: parseInt(options.page || '1'),
                 limit: parseInt(options.limit || '20'),
-                sort_by: (options.sort || 'created_at'),
-                sort_order: (options.order || 'desc')
+                sort: options.sort || 'created_at',
+                order: options.order || 'desc'
             };
             if (options.type)
                 params.memory_type = options.type;
             if (options.tags)
-                params.tags = options.tags.split(',').map(t => t.trim());
-            // Note: user_id filtering removed as it's handled by authentication
+                params.tags = options.tags;
+            if (options.userId)
+                params.user_id = options.userId;
             const result = await apiClient.getMemories(params);
-            if (spinner)
-                spinner.stop();
-            if (result.data.length === 0) {
-                if (output.isJsonOutput()) {
-                    output.json({ data: [], pagination: result.pagination });
-                }
-                else {
-                    console.log(chalk.yellow('No memories found'));
-                }
+            spinner.stop();
+            const memories = result.memories || result.data || [];
+            if (memories.length === 0) {
+                console.log(chalk.yellow('No memories found'));
                 return;
             }
-            if (output.isJsonOutput()) {
-                output.json(result);
+            console.log(chalk.blue.bold(`\n📚 Memories (${result.pagination.total} total)`));
+            console.log(chalk.gray(`Page ${result.pagination.page || 1} of ${result.pagination.pages || Math.ceil(result.pagination.total / result.pagination.limit)}`));
+            console.log();
+            const outputFormat = process.env.CLI_OUTPUT_FORMAT || 'table';
+            if (outputFormat === 'json') {
+                console.log(JSON.stringify(result, null, 2));
             }
             else {
-                console.log(chalk.blue.bold(`\n📚 Memories (${result.pagination.total} total)`));
-                const currentPage = Math.floor(result.pagination.offset / result.pagination.limit) + 1;
-                const totalPages = Math.ceil(result.pagination.total / result.pagination.limit);
-                console.log(chalk.gray(`Page ${currentPage} of ${totalPages}`));
-                console.log();
                 // Table format
-                const tableData = result.data.map((memory) => [
+                const tableData = memories.map((memory) => [
                     truncateText(memory.title, 30),
                     memory.memory_type,
                     memory.tags.slice(0, 3).join(', '),
@@ -153,6 +136,7 @@ export function memoryCommands(program) {
                     memory.access_count
                 ]);
                 const tableConfig = {
+                    header: ['Title', 'Type', 'Tags', 'Created', 'Access'],
                     columnDefault: {
                         width: 20,
                         wrapWord: true
@@ -165,12 +149,13 @@ export function memoryCommands(program) {
                         { width: 8 }
                     ]
                 };
-                const tableHeaders = ['Title', 'Type', 'Tags', 'Created', 'Access'];
-                console.log(table([tableHeaders, ...tableData], tableConfig));
+                console.log(table([tableConfig.header, ...tableData], {
+                    columnDefault: tableConfig.columnDefault,
+                    columns: tableConfig.columns
+                }));
                 // Pagination info
-                if (result.pagination.has_more) {
-                    const nextPage = currentPage + 1;
-                    console.log(chalk.gray(`\nUse --page ${nextPage} for next page`));
+                if (result.pagination.pages > 1) {
+                    console.log(chalk.gray(`\nUse --page ${result.pagination.page + 1} for next page`));
                 }
             }
         }
@@ -191,7 +176,7 @@ export function memoryCommands(program) {
         .option('--tags <tags>', 'filter by tags (comma-separated)')
         .action(async (query, options) => {
         try {
-            const spinner = output.isSilent() ? null : ora(`Searching for "${query}"...`).start();
+            const spinner = ora(`Searching for "${query}"...`).start();
             const searchOptions = {
                 limit: parseInt(options.limit || '20'),
                 threshold: parseFloat(options.threshold || '0.7')
@@ -203,35 +188,25 @@ export function memoryCommands(program) {
                 searchOptions.tags = options.tags.split(',').map((t) => t.trim());
             }
             const result = await apiClient.searchMemories(query, searchOptions);
-            if (spinner)
-                spinner.stop();
-            if (result.data.length === 0) {
-                if (output.isJsonOutput()) {
-                    output.json({ data: [], pagination: result.pagination, query });
-                }
-                else {
-                    console.log(chalk.yellow('No memories found matching your search'));
-                }
+            spinner.stop();
+            const results = result.results || result.data || [];
+            if (results.length === 0) {
+                console.log(chalk.yellow('No memories found matching your search'));
                 return;
             }
-            if (output.isJsonOutput()) {
-                output.json({ ...result, query });
-            }
-            else {
-                console.log(chalk.blue.bold(`\n🔍 Search Results (${result.pagination.total} found)`));
-                console.log(chalk.gray(`Query: "${query}"`));
+            console.log(chalk.blue.bold(`\n🔍 Search Results (${result.total_results || results.length} found)`));
+            console.log(chalk.gray(`Query: "${query}" | Search time: ${result.search_time_ms || 0}ms`));
+            console.log();
+            results.forEach((memory, index) => {
+                const score = (memory.relevance_score * 100).toFixed(1);
+                console.log(chalk.green(`${index + 1}. ${memory.title}`) + chalk.gray(` (${score}% match)`));
+                console.log(chalk.white(`   ${truncateText(memory.content, 100)}`));
+                console.log(chalk.cyan(`   ID: ${memory.id}`) + chalk.gray(` | Type: ${memory.memory_type}`));
+                if (memory.tags.length > 0) {
+                    console.log(chalk.yellow(`   Tags: ${memory.tags.join(', ')}`));
+                }
                 console.log();
-                result.data.forEach((memory, index) => {
-                    const score = (memory.relevance_score * 100).toFixed(1);
-                    console.log(chalk.green(`${index + 1}. ${memory.title}`) + chalk.gray(` (${score}% match)`));
-                    console.log(chalk.white(`   ${truncateText(memory.content, 100)}`));
-                    console.log(chalk.cyan(`   ID: ${memory.id}`) + chalk.gray(` | Type: ${memory.memory_type}`));
-                    if (memory.tags.length > 0) {
-                        console.log(chalk.yellow(`   Tags: ${memory.tags.join(', ')}`));
-                    }
-                    console.log();
-                });
-            }
+            });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';