@lanonasis/cli 3.8.0 → 3.9.0

package/CHANGELOG.md

@@ -0,0 +1,195 @@
+# Changelog - @lanonasis/cli
+
+## [3.9.0] - 2026-02-01
+
+### 🎨 CLI UX Revolution
+
+#### Seamless Multi-Line Text Input
+- **Inline Text Editor**: Professional multi-line text input without external editors
+  - Raw terminal mode for keystroke capture
+  - Full editing support (arrow keys, backspace, newlines)
+  - Visual feedback with line numbers and cursor indicators
+  - Submit with Ctrl+D, cancel with Ctrl+C
+  - Configurable fallback to external editors
+
+#### Intelligent MCP Server Connection Management
+- **Auto-Configuration**: Automatically detects and configures embedded MCP servers
+- **Connection Lifecycle**: Smart server process management with health monitoring
+- **Persistent Configuration**: Saves and loads user preferences across sessions
+- **Connection Verification**: Validates server connectivity before operations
+- **Graceful Error Handling**: Clear error messages with actionable resolution steps
+
+#### First-Run Onboarding Experience
+- **Guided Setup**: Interactive onboarding flow for new users
+- **Connectivity Testing**: Automatic testing of API endpoints and services
+- **Smart Defaults**: Configures optimal settings based on environment
+- **User Preferences**: Captures and persists input mode, editor choice, and behavior preferences
+- **Troubleshooting Guidance**: Context-aware help when issues are detected
+
+### 🐛 Critical Bug Fixes (PR #93)
+
+#### P1: Connection Verification False Positive
+- **Issue**: `verifyConnection()` returned `true` even when server was in error/stopped state
+- **Fix**: Added explicit checks for error and stopped states before declaring success
+- **Impact**: Users will now see accurate connection status instead of false positives
+
+#### P2: Configuration Not Loaded Before Use
+- **Issue**: `ConnectionManager.init()` method existed but was never called
+- **Fix**: Added `init()` to ConnectionManager interface and call it before `connectLocal()`
+- **Impact**: User configuration is now properly loaded and respected
+
+#### P2: Empty Content Overwrites in Inline Updates
+- **Issue**: When updating memories in inline mode, `defaultContent` wasn't passed to TextInputHandler
+- **Fix**: Added `defaultContent` support throughout the text input pipeline
+- **Impact**: Memory updates preserve existing content instead of starting with blank slate
+
+### 🧪 Testing & Quality
+
+- **Comprehensive Test Suite**: 168 passing tests including property-based tests
+- **Zero TypeScript Errors**: All compilation errors resolved
+- **No Regressions**: All existing tests continue to pass
+- **Professional Documentation**: Complete inline documentation and type definitions
+
+### 📦 Package Cleanup
+
+- **npmignore**: Excludes test files and development artifacts from published package
+- **Directory Reorganization**: Cleaner structure with examples moved to `docs/examples/`
+- **Build Optimization**: Reduced package size by excluding unnecessary files
+
+### 🔄 Breaking Changes
+None - Fully backward compatible
+
+### 📝 Technical Details
+
+**New Implementations**:
+- `TextInputHandlerImpl` ([cli/src/ux/implementations/TextInputHandlerImpl.ts](cli/src/ux/implementations/TextInputHandlerImpl.ts))
+- `ConnectionManagerImpl` ([cli/src/ux/implementations/ConnectionManagerImpl.ts](cli/src/ux/implementations/ConnectionManagerImpl.ts))
+- `OnboardingFlowImpl` ([cli/src/ux/implementations/OnboardingFlowImpl.ts](cli/src/ux/implementations/OnboardingFlowImpl.ts))
+
+**Integration Points**:
+- Memory commands now use inline text input by default ([cli/src/commands/memory.ts](cli/src/commands/memory.ts:116-119))
+- MCP connect command uses ConnectionManager ([cli/src/commands/mcp.ts](cli/src/commands/mcp.ts:130-137))
+- Init command includes onboarding flow ([cli/src/commands/init.ts](cli/src/commands/init.ts))
+
+## [3.7.0] - 2025-11-23
+
+### 🔐 Security Infrastructure Upgrade
+
+#### Enhanced API Key Security with SHA-256
+- **Cross-Platform SHA-256 Hashing**: Unified hash utilities for consistent API key hashing across all platforms
+- **Local Hash Implementation**: Isolated hash utilities (`src/utils/hash-utils.ts`) for CLI independence
+- **Double-Hash Prevention**: Smart detection of pre-hashed keys to prevent double-hashing errors
+- **Server-Side Validation**: Constant-time comparison for timing-attack prevention
+- **Future NPM Package Ready**: Designed for eventual migration to `@lanonasis/security` npm package
+
+#### Technical Improvements
+- **Build Stability**: Fixed TypeScript `rootDir` compilation errors
+- **Zero Deprecation Warnings**: All dependencies verified for production readiness
+- **Cross-Platform Compatibility**: Node.js crypto for server-side, Web Crypto API fallback for browser contexts
+- **Type Safety**: Full TypeScript support with exported hash types (`ApiKeyHash`, `ApiKey`)
+
+#### Hash Utility Functions
+```typescript
+// Available in CLI
+ensureApiKeyHash(apiKey: string): string  // Smart hash normalization
+hashApiKey(apiKey: string): string        // SHA-256 hashing
+isSha256Hash(value: string): boolean      // Hash detection
+```
+
+### 🛡️ Security Features
+- ✅ SHA-256 cryptographic hashing for all API keys
+- ✅ Prevents plaintext key transmission
+- ✅ Constant-time hash comparison
+- ✅ Automatic hash detection and normalization
+- ✅ Compatible with existing vendor key authentication
+
+### 🔄 Breaking Changes
+None - Fully backward compatible
+
+### 📦 Dependencies
+- No new external dependencies
+- Uses native Node.js `crypto` module
+- Clean build with zero deprecation warnings
+
+## [3.0.1] - 2025-10-08
+
+### 🚀 Major Version Bump
+This is a major version release (3.0) due to the significant MCP architectural changes and new capabilities that may affect existing integrations.
+
+### 🎉 Major Features
+*Same as 2.0.9 but republished as 3.0.1 due to npm version conflict*
+
+## [2.0.9] - 2025-10-08 (npm publish conflict)
+
+### 🎉 Major Features
+
+#### Enhanced Model Context Protocol (MCP) Support
+- **Multi-Server Connections**: Connect to multiple MCP servers simultaneously with automatic failover
+- **Advanced Error Handling**: Exponential backoff retry logic and graceful degradation  
+- **Health Monitoring**: Automatic health checks with latency tracking and auto-reconnection
+- **Connection Pooling**: Efficient resource management for multiple connections
+- **Tool Chain Execution**: Support for sequential and parallel tool execution
+
+#### New MCP Infrastructure
+- **Enhanced MCP Client** (`src/mcp/client/enhanced-client.ts`)
+  - Multi-server management with priority-based selection
+  - Event-driven architecture with connection status tracking
+  - Automatic failover to backup servers
+
+- **MCP Server Implementation** (`src/mcp/server/lanonasis-server.ts`)
+  - Full MCP protocol compliance (tools, resources, prompts)
+  - 16 registered tools for memory, topic, and system operations
+  - Resource providers for data access
+  - Interactive prompts for user guidance
+
+- **Transport Support** (`src/mcp/transports/transport-manager.ts`)
+  - StdIO transport for local processes
+  - WebSocket transport with auto-reconnection
+  - SSE (Server-Sent Events) for streaming
+  - Authentication support (Bearer, API Key, Basic)
+
+- **Schema Validation** (`src/mcp/schemas/tool-schemas.ts`)
+  - Zod-based validation for all MCP tools
+  - Type-safe operations with clear error messages
+  - Comprehensive schemas for memory, topic, API key, and system operations
+
+### 🛠 Technical Improvements
+- **Build System**: New MCP-specific build scripts (`build:mcp`, `dev:mcp`, `test:mcp`)
+- **Module Structure**: Dedicated `/src/mcp/` directory with clean separation of concerns
+- **Error Recovery**: Improved error handling throughout the MCP stack
+- **Type Safety**: Full TypeScript support with proper type definitions
+
+### 🐛 Bug Fixes
+- Fixed authentication flow issues with proper token validation
+- Resolved double slash URL construction in CLI auth
+- Fixed memory command authentication requirements
+- Corrected error messages to show correct authentication command
+
+### 📚 Documentation
+- Enhanced README with MCP usage examples
+- Added MCP Server Mode documentation
+- Updated command reference with new MCP features
+- Created comprehensive MCP enhancement summary
+
+### ⚠️ Breaking Changes
+- HTTP transport temporarily disabled in favor of WebSocket/StdIO (more reliable)
+- Some API key operations pending full implementation
+
+### 🔄 Dependencies
+- Updated to latest @modelcontextprotocol/sdk
+- Added ws for WebSocket support
+- Added zod for schema validation
+
+## [2.0.8] - Previous Version
+- Authentication system improvements
+- CLI guided setup enhancements
+- Performance optimizations
+
+## [2.0.7] - Previous Version
+- Memory management improvements
+- Topic organization features
+- Bug fixes and stability improvements
+
+---
+
+For full release notes and migration guides, visit: https://docs.lanonasis.com/cli/changelog

package/README.md

@@ -1,11 +1,11 @@
-# @lanonasis/cli v3.7.0 - Enterprise Security & MCP Experience
+# @lanonasis/cli v3.9.0 - Enterprise Security & Professional UX
 
 [![NPM Version](https://img.shields.io/npm/v/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![Downloads](https://img.shields.io/npm/dt/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Golden Contract](https://img.shields.io/badge/Onasis--Core-v0.1%20Compliant-gold)](https://api.lanonasis.com/.well-known/onasis.json)
 
-🚀 **NEW IN v3.0**: Advanced Model Context Protocol (MCP) support with multi-server connections, enhanced error handling, and enterprise-grade transport protocols. Revolutionary interactive CLI experience with guided workflows, smart suggestions, achievement system, and power user mode. Professional command-line interface for LanOnasis Memory as a Service (MaaS) platform with **Golden Contract compliance**.
+🎉 **NEW IN v3.9**: Professional CLI UX with seamless inline text editing, intelligent MCP connection management, and first-run onboarding. Advanced Model Context Protocol (MCP) support with multi-server connections, enhanced error handling, and enterprise-grade transport protocols. Revolutionary interactive CLI experience with guided workflows and **Golden Contract compliance**.
 
 ## 🚀 Quick Start
 
@@ -34,6 +34,69 @@ onasis health                                   # Verify system health
 onasis memory create --title "Welcome" --content "My first memory"
 ```
 
+## ✨ Professional CLI UX (v3.9.0+)
+
+### Seamless Inline Text Editing
+No more external editor dependencies! Create and update memories with a professional inline text editor:
+
+```bash
+# Create memory with inline multi-line editor
+onasis memory create --inline
+# Type your content directly in the terminal
+# Use arrow keys to navigate, Enter for new lines
+# Ctrl+D to save, Ctrl+C to cancel
+
+# Update existing memory
+onasis memory update <id> --inline
+# Your existing content is preserved and editable
+```
+
+**Features**:
+- ✨ Multi-line editing with visual feedback
+- 🎯 Line numbers and cursor indicators
+- ⌨️ Full keyboard navigation (arrows, backspace, etc.)
+- 💾 Auto-preserves existing content when updating
+- 🚫 No external editor configuration needed
+
+### Intelligent MCP Connection
+Automatic MCP server discovery and configuration:
+
+```bash
+# Connect to local MCP server (auto-configured)
+onasis mcp connect --local
+# Server path detected automatically
+# Configuration persisted for next time
+
+# Check connection status
+onasis mcp status
+```
+
+**Features**:
+- 🔍 Auto-detects embedded MCP server
+- 💾 Saves configuration automatically
+- 🔄 Health monitoring and auto-reconnection
+- ✅ Connection verification before operations
+- 🛠️ Clear error messages with fix suggestions
+
+### First-Run Onboarding
+Interactive setup for new users:
+
+```bash
+onasis init
+# Guided setup walks you through:
+# - API configuration
+# - Connectivity testing
+# - Input mode preferences
+# - Troubleshooting if needed
+```
+
+**Features**:
+- 📋 Step-by-step guided setup
+- 🧪 Automatic connectivity tests
+- ⚙️ Smart default configuration
+- 💡 Context-aware troubleshooting
+- 📖 Interactive help and tips
+
 ## 🤖 Claude Desktop Integration
 
 For instant Claude Desktop MCP integration with OAuth2 authentication, see our [Claude Desktop Setup Guide](./CLAUDE_DESKTOP_SETUP.md).

package/dist/commands/auth.js

@@ -707,7 +707,7 @@ async function handleOAuthFlow(config) {
         await config.setToken(tokens.access_token);
         await config.set('refresh_token', tokens.refresh_token);
         await config.set('token_expires_at', Date.now() + (tokens.expires_in * 1000));
-        await config.set('authMethod', 'oauth2');
+        await config.set('authMethod', 'oauth');
         // The OAuth access token from auth-gateway works as the API token for all services
         // Store it as the vendor key equivalent for MCP and API access
         spinner.text = 'Configuring unified access...';

package/dist/commands/config.js

@@ -391,8 +391,9 @@ export function configCommands(program) {
         else {
             console.log(chalk.green('   ✓ Authentication credentials found'));
             // Validate auth method consistency
-            if (vendorKey && authMethod !== 'vendor_key') {
-                console.log(chalk.yellow('   ⚠ Auth method mismatch (has vendor key but method is not vendor_key)'));
+            // Note: OAuth users can have vendorKey stored (for MCP access) while authMethod is 'oauth'
+            if (vendorKey && authMethod !== 'vendor_key' && authMethod !== 'oauth') {
+                console.log(chalk.yellow('   ⚠ Auth method mismatch (has vendor key but method is not vendor_key or oauth)'));
                 validation.issues.push('Auth method mismatch');
                 if (options.repair) {
                     config.set('authMethod', 'vendor_key');

package/dist/commands/init.js

@@ -1,8 +1,11 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
+import { dirname, join } from 'path';
 import { CLIConfig } from '../utils/config.js';
+import { createOnboardingFlow } from '../ux/index.js';
 export async function initCommand(options) {
     const config = new CLIConfig();
+    await config.init();
     console.log(chalk.blue.bold('🚀 Initializing MaaS CLI'));
     console.log();
     // Check if config already exists
@@ -21,6 +24,15 @@ export async function initCommand(options) {
             return;
         }
     }
+    const onboardingConfigPath = join(dirname(config.getConfigPath()), 'onboarding.json');
+    const onboardingFlow = createOnboardingFlow(onboardingConfigPath);
+    const setupResult = await onboardingFlow.runInitialSetup();
+    if (!setupResult.completed && setupResult.issues && setupResult.issues.length > 0) {
+        console.log(chalk.yellow('⚠️  Onboarding completed with issues:'));
+        setupResult.issues.forEach((issue) => console.log(chalk.yellow(`  • ${issue}`)));
+    }
+    // Reload config after onboarding to preserve generated defaults
+    await config.load();
     // Get configuration
     const answers = await inquirer.prompt([
         {

package/dist/commands/mcp.js

@@ -5,6 +5,8 @@ import { getMCPClient } from '../utils/mcp-client.js';
 import { EnhancedMCPClient } from '../mcp/client/enhanced-client.js';
 import { CLIConfig } from '../utils/config.js';
 import WebSocket from 'ws';
+import { dirname, join } from 'path';
+import { createConnectionManager } from '../ux/index.js';
 /**
  * Register MCP-related CLI commands (mcp and mcp-server) on a Commander program.
  *
@@ -79,6 +81,7 @@ export function mcpCommands(program) {
         .action(async (options) => {
         const spinner = ora('Connecting to MCP server...').start();
         const config = new CLIConfig();
+        await config.init();
         try {
             let connectionMode;
             // Determine connection mode - WebSocket takes precedence over remote and local
@@ -112,6 +115,30 @@ export function mcpCommands(program) {
             let connected = false;
             // Use Enhanced MCP Client for better connection handling
             const enhancedClient = new EnhancedMCPClient();
+            if (connectionMode === 'local' && !options.localArgs && !options.url) {
+                const configDir = dirname(config.getConfigPath());
+                const manager = createConnectionManager(join(configDir, 'mcp-config.json'));
+                // Initialize manager to load persisted config
+                await manager.init();
+                if (options.server) {
+                    await manager.updateConfig({ localServerPath: options.server });
+                }
+                const result = await manager.connectLocal();
+                if (result.success) {
+                    spinner.succeed(chalk.green('Connected to local MCP server'));
+                    process.exit(0);
+                }
+                else {
+                    spinner.fail(result.error || 'Failed to connect to local MCP server');
+                    if (result.suggestions && result.suggestions.length > 0) {
+                        result.suggestions.forEach((suggestion) => {
+                            console.log(chalk.yellow(`  • ${suggestion}`));
+                        });
+                    }
+                    process.exit(1);
+                }
+                return;
+            }
             if (options.url) {
                 // Connect to specific URL (WebSocket or remote)
                 const serverConfig = {
@@ -169,6 +196,7 @@ export function mcpCommands(program) {
         const client = getMCPClient();
         await client.disconnect();
         console.log(chalk.green('✓ Disconnected from MCP server'));
+        process.exit(0);
     });
     // Status command
     mcp.command('status')
@@ -183,6 +211,7 @@ export function mcpCommands(program) {
         await config.init();
         let healthLabel = chalk.gray('Unknown');
         let healthDetails;
+        let isServiceReachable = false;
         try {
             const axios = (await import('axios')).default;
             // Derive MCP health URL from discovered REST base (e.g. https://mcp.lanonasis.com/api/v1 -> https://mcp.lanonasis.com/health)
@@ -207,14 +236,17 @@ export function mcpCommands(program) {
             const overallStatus = String(response.data?.status ?? '').toLowerCase();
             const ok = response.status === 200 && (!overallStatus || overallStatus === 'healthy');
             if (ok) {
-                healthLabel = chalk.green('Reachable');
+                healthLabel = chalk.green('Healthy');
+                isServiceReachable = true;
             }
             else {
                 healthLabel = chalk.yellow('Degraded');
+                isServiceReachable = true; // Service is reachable but degraded
             }
         }
         catch (error) {
             healthLabel = chalk.red('Unreachable');
+            isServiceReachable = false;
             if (error instanceof Error) {
                 healthDetails = error.message;
             }
@@ -224,7 +256,14 @@ export function mcpCommands(program) {
         }
         console.log(chalk.cyan('\n📊 MCP Connection Status'));
         console.log(chalk.cyan('========================'));
-        console.log(`Status: ${status.connected ? chalk.green('Connected') : chalk.red('Disconnected')}`);
+        // Show status based on service reachability, not in-memory connection state
+        // The CLI isn't a persistent daemon - "connected" means the service is available
+        if (isServiceReachable) {
+            console.log(`Status: ${chalk.green('Ready')} (service reachable)`);
+        }
+        else {
+            console.log(`Status: ${chalk.red('Unavailable')} (service unreachable)`);
+        }
         // Display mode with proper labels
         let modeDisplay;
         switch (status.mode) {
@@ -246,7 +285,8 @@ export function mcpCommands(program) {
         if (healthDetails && process.env.CLI_VERBOSE === 'true') {
             console.log(chalk.gray(`Health details: ${healthDetails}`));
         }
-        if (status.connected) {
+        // Show features when service is reachable
+        if (isServiceReachable) {
             if (status.mode === 'remote') {
                 console.log(`\n${chalk.cyan('Features:')}`);
                 console.log('• Real-time updates via SSE');
@@ -259,7 +299,12 @@ export function mcpCommands(program) {
                 console.log('• Authenticated WebSocket connection');
                 console.log('• Production-ready MCP server');
             }
+            console.log(chalk.green('\n✓ MCP tools are available. Run "lanonasis mcp tools" to see them.'));
+        }
+        else {
+            console.log(chalk.yellow('\n⚠ MCP service is not reachable. Run "lanonasis mcp diagnose" for troubleshooting.'));
         }
+        process.exit(0);
     });
     // List tools command
     mcp.command('tools')
@@ -456,6 +501,7 @@ export function mcpCommands(program) {
             console.log('  --prefer-local     : Use local stdio mode (development only)');
             console.log('  --auto             : Auto-detect based on configuration (default)');
         }
+        process.exit(0);
     });
     // Start MCP server for external clients
     mcp.command('start')
@@ -790,5 +836,6 @@ export function mcpCommands(program) {
             console.log(chalk.gray('   • Verify your network allows outbound HTTPS connections'));
             console.log(chalk.gray('   • Contact support if issues persist'));
         }
+        process.exit(0);
     });
 }

package/dist/commands/memory.js

@@ -6,6 +6,33 @@ import wrap from 'word-wrap';
 import { format } from 'date-fns';
 import { apiClient } from '../utils/api.js';
 import { formatBytes, truncateText } from '../utils/formatting.js';
+import { CLIConfig } from '../utils/config.js';
+import { createTextInputHandler } from '../ux/index.js';
+const resolveInputMode = async () => {
+    const config = new CLIConfig();
+    await config.init();
+    const directMode = config.get('inputMode');
+    const userPrefs = config.get('userPreferences');
+    const resolved = (directMode || userPrefs?.inputMode);
+    return resolved === 'editor' ? 'editor' : 'inline';
+};
+const collectMemoryContent = async (prompt, inputMode, defaultContent) => {
+    if (inputMode === 'editor') {
+        const { content } = await inquirer.prompt([
+            {
+                type: 'editor',
+                name: 'content',
+                message: prompt,
+                default: defaultContent,
+            },
+        ]);
+        return content;
+    }
+    const handler = createTextInputHandler();
+    return handler.collectMultilineInput(prompt, {
+        defaultContent,
+    });
+};
 export function memoryCommands(program) {
     // Create memory
     program
@@ -22,39 +49,42 @@ export function memoryCommands(program) {
         try {
             let { title, content, type, tags, topicId, interactive } = options;
             if (interactive || (!title || !content)) {
+                const inputMode = await resolveInputMode();
                 const answers = await inquirer.prompt([
                     {
                         type: 'input',
                         name: 'title',
                         message: 'Memory title:',
                         default: title,
-                        validate: (input) => input.length > 0 || 'Title is required'
-                    },
-                    {
-                        type: 'editor',
-                        name: 'content',
-                        message: 'Memory content:',
-                        default: content,
-                        validate: (input) => input.length > 0 || 'Content is required'
+                        validate: (input) => input.length > 0 || 'Title is required',
                     },
                     {
                         type: 'list',
                         name: 'type',
                         message: 'Memory type:',
                         choices: ['conversation', 'knowledge', 'project', 'context', 'reference'],
-                        default: type || 'context'
+                        default: type || 'context',
                     },
                     {
                         type: 'input',
                         name: 'tags',
                         message: 'Tags (comma-separated):',
-                        default: tags || ''
-                    }
+                        default: tags || '',
+                    },
                 ]);
                 title = answers.title;
-                content = answers.content;
                 type = answers.type;
                 tags = answers.tags;
+                const shouldPromptContent = !content || (interactive && inputMode === 'editor');
+                if (shouldPromptContent) {
+                    content = await collectMemoryContent('Memory content:', inputMode, content);
+                }
+            }
+            if (!title || title.trim().length === 0) {
+                throw new Error('Title is required');
+            }
+            if (!content || content.trim().length === 0) {
+                throw new Error('Content is required');
             }
             const spinner = ora('Creating memory...').start();
             const memoryData = {
@@ -275,36 +305,32 @@ export function memoryCommands(program) {
                 const spinner = ora('Fetching current memory...').start();
                 const currentMemory = await apiClient.getMemory(id);
                 spinner.stop();
+                const inputMode = await resolveInputMode();
                 const answers = await inquirer.prompt([
                     {
                         type: 'input',
                         name: 'title',
                         message: 'Title:',
-                        default: currentMemory.title
-                    },
-                    {
-                        type: 'editor',
-                        name: 'content',
-                        message: 'Content:',
-                        default: currentMemory.content
+                        default: currentMemory.title,
                     },
                     {
                         type: 'list',
                         name: 'type',
                         message: 'Memory type:',
                         choices: ['conversation', 'knowledge', 'project', 'context', 'reference'],
-                        default: currentMemory.memory_type
+                        default: currentMemory.memory_type,
                     },
                     {
                         type: 'input',
                         name: 'tags',
                         message: 'Tags (comma-separated):',
-                        default: currentMemory.tags.join(', ')
-                    }
+                        default: currentMemory.tags?.join(', ') || '',
+                    },
                 ]);
+                const content = await collectMemoryContent('Content:', inputMode, currentMemory.content);
                 updateData = {
                     title: answers.title,
-                    content: answers.content,
+                    content,
                     memory_type: answers.type,
                     tags: answers.tags.split(',').map((tag) => tag.trim()).filter(Boolean)
                 };

package/dist/index.js

@@ -12,6 +12,8 @@ import { mcpCommands } from './commands/mcp.js';
 import apiKeysCommand from './commands/api-keys.js';
 import { CLIConfig } from './utils/config.js';
 import { getMCPClient } from './utils/mcp-client.js';
+import { dirname, join } from 'path';
+import { createOnboardingFlow } from './ux/index.js';
 // Load environment variables
 config();
 import { createRequire } from 'module';
@@ -51,6 +53,24 @@ program
         process.env.MEMORY_API_URL = opts.apiUrl;
     }
     process.env.CLI_OUTPUT_FORMAT = opts.output;
+    const skipOnboarding = actionCommand.name() === 'init' ||
+        actionCommand.name() === 'auth' ||
+        actionCommand.parent?.name?.() === 'auth';
+    if (!skipOnboarding) {
+        try {
+            const onboardingConfigPath = join(dirname(cliConfig.getConfigPath()), 'onboarding.json');
+            const onboardingFlow = createOnboardingFlow(onboardingConfigPath);
+            if (onboardingFlow.detectFirstRun()) {
+                await onboardingFlow.runInitialSetup();
+            }
+        }
+        catch (error) {
+            if (process.env.CLI_VERBOSE === 'true') {
+                console.log(colors.warning('Onboarding skipped due to error'));
+                console.log(colors.muted(`Error: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        }
+    }
     // Auto-initialize MCP unless disabled
     const isMcpFlow = actionCommand.name() === 'mcp' ||
         actionCommand.parent?.name?.() === 'mcp' ||

package/dist/mcp/access-control.js

@@ -192,7 +192,7 @@ export class MemoryAccessControl {
             const apiUrl = this.config.get('apiUrl') || 'https://api.lanonasis.com';
             const token = this.config.get('token');
             const axios = (await import('axios')).default;
-            const response = await axios.get(`${apiUrl}/api/v1/memory/${memoryId}`, {
+            const response = await axios.get(`${apiUrl}/api/v1/memories/${memoryId}`, {
                 headers: {
                     'Authorization': `Bearer ${token}`,
                     'Content-Type': 'application/json'
@@ -210,7 +210,7 @@ export class MemoryAccessControl {
             const apiUrl = this.config.get('apiUrl') || 'https://api.lanonasis.com';
             const token = this.config.get('token');
             const axios = (await import('axios')).default;
-            const response = await axios.get(`${apiUrl}/api/v1/memory?user_id=${userId}`, {
+            const response = await axios.get(`${apiUrl}/api/v1/memories?user_id=${userId}`, {
                 headers: {
                     'Authorization': `Bearer ${token}`,
                     'Content-Type': 'application/json'