@lanonasis/cli 3.8.1 → 3.9.1

package/CHANGELOG.md

@@ -0,0 +1,224 @@
+# Changelog - @lanonasis/cli
+
+## [3.9.1] - 2026-02-01
+
+### 🔐 Authentication Fixes
+
+- **OAuth Scope Clarification**: OAuth login now clearly states it enables MCP integration only
+- **Improved Error Messages**: 401 errors for OAuth users include specific guidance for direct API access
+- **Removed Misleading Storage**: OAuth tokens are no longer incorrectly stored as vendor keys
+- **Documentation Updates**: README and in-CLI help clarify authentication method differences
+
+### 🐛 Bug Fixes
+
+- Fixed confusing error message when OAuth users try to use direct CLI commands
+- Removed `.lanonasis/mcp-config.json` from version control
+
+## [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
+
+### 🔐 Authentication Clarifications
+
+#### OAuth vs Direct API Access
+- **Clear Scope Documentation**: OAuth2 login now explicitly states it enables MCP integration
+- **Improved Error Messages**: 401 errors for OAuth users include specific guidance for direct API access
+- **Authentication Method Guidance**: CLI provides clear instructions for:
+  - **OAuth**: Use for MCP integration and real-time features
+  - **Vendor Key**: Obtain from dashboard for direct API access (`lanonasis auth login --vendor`)
+  - **Credentials**: Use username/password for direct API access (`lanonasis auth login --credentials`)
+
+#### Secure Storage Fallback
+- **Keytar Optional**: When keytar (native secure storage) is unavailable, CLI gracefully falls back to encrypted file storage
+- **Cross-Platform**: Encrypted storage works consistently across all platforms
+- **No Data Loss**: Credentials are preserved in `~/.lanonasis/api-key.enc` with AES-256-GCM encryption
+
+### 🐛 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).
@@ -93,12 +156,14 @@ onasis login --vendor-key <your-vendor-key>
 
 ### 2. OAuth Browser Authentication
 
-Secure browser-based authentication:
+Secure browser-based authentication for MCP integration:
 
 ```bash
 onasis login --oauth
 ```
 
+> **Note**: OAuth authentication enables MCP integration features (real-time updates, WebSocket connections). For direct CLI memory commands (`memory list`, `memory create`, etc.), use vendor key or credentials authentication.
+
 ### 3. Interactive Credentials
 
 Traditional username/password authentication:

package/dist/commands/auth.js

@@ -702,23 +702,22 @@ async function handleOAuthFlow(config) {
         }
         const tokens = await exchangeCodeForTokens(code, pkce.verifier, authBase, redirectUri);
         spinner.succeed('Access tokens received');
-        // Store OAuth tokens - these are already valid auth-gateway tokens from /oauth/token
-        // No need for additional exchange since /oauth/token returns auth-gateway's own tokens
+        // Store OAuth tokens - these are auth-gateway tokens from /oauth/token
+        // Note: OAuth tokens are valid for MCP services but not for direct API access
         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', '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...';
-        spinner.start();
-        // Use the OAuth access token directly - it's already an auth-gateway token
-        await config.setVendorKey(tokens.access_token);
-        spinner.succeed('Unified authentication configured');
+        spinner.succeed('OAuth tokens stored');
         console.log();
         console.log(chalk.green('✓ OAuth2 authentication successful'));
-        console.log(colors.info('You can now use all Lanonasis services'));
-        console.log(chalk.gray('✓ MCP, API, and CLI access configured'));
+        console.log(colors.info('You can now use MCP integration features'));
+        console.log();
+        console.log(chalk.yellow('Note: ') + chalk.gray('OAuth login enables MCP integration.'));
+        console.log(chalk.gray('For direct CLI memory commands, use:'));
+        console.log(chalk.cyan('  lanonasis auth login --vendor') + chalk.gray(' (get a vendor key from dashboard)'));
+        console.log(chalk.gray('  OR'));
+        console.log(chalk.cyan('  lanonasis auth login --credentials') + chalk.gray(' (use username/password)'));
         process.exit(0);
     }
     catch (error) {

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 = {
@@ -185,12 +212,38 @@ export function mcpCommands(program) {
         let healthLabel = chalk.gray('Unknown');
         let healthDetails;
         let isServiceReachable = false;
+        let resolvedHealthUrl;
         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)
-            const restUrl = config.getMCPRestUrl();
-            const rootBase = restUrl.replace(/\/api\/v1$/, '');
-            const healthUrl = `${rootBase}/health`;
+            const normalizeMcpHealthUrl = (inputUrl) => {
+                const parsed = new URL(inputUrl);
+                if (parsed.protocol === 'wss:') {
+                    parsed.protocol = 'https:';
+                }
+                else if (parsed.protocol === 'ws:') {
+                    parsed.protocol = 'http:';
+                }
+                parsed.pathname = '/health';
+                parsed.search = '';
+                parsed.hash = '';
+                return parsed.toString();
+            };
+            // Prefer MCP host health based on active mode:
+            // - websocket: use configured websocket host (wss -> https)
+            // - remote: use configured MCP REST host
+            // - local/default: fall back to discovered MCP REST host
+            let healthProbeBase;
+            if (status.mode === 'websocket') {
+                healthProbeBase = config.get('mcpWebSocketUrl') ?? config.getMCPServerUrl();
+            }
+            else if (status.mode === 'remote') {
+                healthProbeBase = config.get('mcpServerUrl') ?? config.getMCPRestUrl();
+            }
+            else {
+                healthProbeBase = config.getMCPRestUrl();
+            }
+            const healthUrl = normalizeMcpHealthUrl(healthProbeBase);
+            resolvedHealthUrl = healthUrl;
             const token = config.getToken();
             const vendorKey = await config.getVendorKeyAsync();
             const headers = {};
@@ -207,7 +260,8 @@ export function mcpCommands(program) {
                 timeout: 5000
             });
             const overallStatus = String(response.data?.status ?? '').toLowerCase();
-            const ok = response.status === 200 && (!overallStatus || overallStatus === 'healthy');
+            const okStatuses = new Set(['healthy', 'ok', 'up']);
+            const ok = response.status === 200 && (!overallStatus || okStatuses.has(overallStatus));
             if (ok) {
                 healthLabel = chalk.green('Healthy');
                 isServiceReachable = true;
@@ -258,6 +312,9 @@ export function mcpCommands(program) {
         if (healthDetails && process.env.CLI_VERBOSE === 'true') {
             console.log(chalk.gray(`Health details: ${healthDetails}`));
         }
+        if (resolvedHealthUrl && process.env.CLI_VERBOSE === 'true') {
+            console.log(chalk.gray(`Health probe URL: ${resolvedHealthUrl}`));
+        }
         // Show features when service is reachable
         if (isServiceReachable) {
             if (status.mode === 'remote') {

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: 'input',
-                        name: 'content',
-                        message: 'Memory content (or use -c flag for multi-line):',
-                        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' ||