@lanonasis/cli 1.5.1 → 2.0.0

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,12 +1,151 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
+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 MaaS (Supabase Auth)'));
+    console.log(chalk.blue.bold('🔐 Onasis-Core Golden Contract Authentication'));
+    console.log(colors.info('━'.repeat(50)));
+    console.log();
+    // Enhanced authentication flow - check for vendor key first
+    if (options.vendorKey) {
+        await handleVendorKeyAuth(options.vendorKey, config);
+        return;
+    }
+    // Show authentication options
+    const authChoice = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'method',
+            message: 'Choose authentication method:',
+            choices: [
+                {
+                    name: '🔑 Vendor Key (Recommended for API access)',
+                    value: 'vendor'
+                },
+                {
+                    name: '🌐 Web OAuth (Browser-based)',
+                    value: 'oauth'
+                },
+                {
+                    name: '⚙️  Username/Password (Direct credentials)',
+                    value: 'credentials'
+                }
+            ]
+        }
+    ]);
+    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;
+    }
+    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

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>;

package/dist/commands/completion.js

@@ -0,0 +1,378 @@
+import chalk from 'chalk';
+import { CLIConfig } from '../utils/config.js';
+import { apiClient } from '../utils/api.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 generateCompletionData() {
+    const config = new CLIConfig();
+    await config.init();
+    // Dynamic data that might come from API or config
+    let memoryTypes = ['context', 'project', 'knowledge', 'reference', 'personal', 'workflow'];
+    let topics = [];
+    try {
+        // Try to fetch dynamic data if authenticated
+        if (await config.isAuthenticated()) {
+            const topicsData = await apiClient.getTopics();
+            topics = topicsData.map(t => t.name);
+        }
+    }
+    catch {
+        // Ignore errors in completion generation
+    }
+    const completionData = {
+        commands: [
+            {
+                name: 'init',
+                description: 'Initialize CLI configuration',
+                subcommands: []
+            },
+            {
+                name: 'auth',
+                aliases: ['login'],
+                description: 'Authentication commands',
+                subcommands: [
+                    {
+                        name: 'login',
+                        description: 'Login to your account',
+                        options: [
+                            { name: '--email', description: 'Email address', type: 'string' },
+                            { name: '--password', description: 'Password', type: 'string' },
+                            { name: '--vendor-key', description: 'Vendor key (pk_xxx.sk_xxx)', type: 'string' },
+                            { name: '--oauth', description: 'Use OAuth flow', type: 'boolean' }
+                        ]
+                    },
+                    {
+                        name: 'logout',
+                        description: 'Logout from your account',
+                        options: []
+                    },
+                    {
+                        name: 'status',
+                        description: 'Show authentication status',
+                        options: []
+                    }
+                ]
+            },
+            {
+                name: 'memory',
+                aliases: ['mem'],
+                description: 'Memory management commands',
+                subcommands: [
+                    {
+                        name: 'list',
+                        description: 'List memories',
+                        options: [
+                            { name: '--limit', description: 'Number of results', type: 'number' },
+                            { name: '--offset', description: 'Results offset', type: 'number' },
+                            { name: '--memory-type', description: 'Filter by memory type', type: 'choice', choices: memoryTypes },
+                            { name: '--sort-by', description: 'Sort field', type: 'choice', choices: ['created_at', 'updated_at', 'last_accessed', 'access_count'] },
+                            { name: '--sort-order', description: 'Sort order', type: 'choice', choices: ['asc', 'desc'] },
+                            { name: '--tags', description: 'Filter by tags', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'create',
+                        description: 'Create a new memory',
+                        options: [
+                            { name: '--title', description: 'Memory title', type: 'string', required: true },
+                            { name: '--content', description: 'Memory content', type: 'string', required: true },
+                            { name: '--memory-type', description: 'Memory type', type: 'choice', choices: memoryTypes },
+                            { name: '--tags', description: 'Comma-separated tags', type: 'string' },
+                            { name: '--topic-id', description: 'Topic ID', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'get',
+                        description: 'Get a specific memory',
+                        options: [
+                            { name: 'id', description: 'Memory ID', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'update',
+                        description: 'Update an existing memory',
+                        options: [
+                            { name: 'id', description: 'Memory ID', type: 'string', required: true },
+                            { name: '--title', description: 'Memory title', type: 'string' },
+                            { name: '--content', description: 'Memory content', type: 'string' },
+                            { name: '--memory-type', description: 'Memory type', type: 'choice', choices: memoryTypes },
+                            { name: '--tags', description: 'Comma-separated tags', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'delete',
+                        description: 'Delete a memory',
+                        options: [
+                            { name: 'id', description: 'Memory ID', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'search',
+                        description: 'Search memories',
+                        options: [
+                            { name: 'query', description: 'Search query', type: 'string', required: true },
+                            { name: '--memory-types', description: 'Filter by memory types', type: 'string' },
+                            { name: '--limit', description: 'Number of results', type: 'number' },
+                            { name: '--threshold', description: 'Relevance threshold', type: 'number' }
+                        ]
+                    },
+                    {
+                        name: 'stats',
+                        description: 'Show memory statistics',
+                        options: []
+                    },
+                    {
+                        name: 'bulk-delete',
+                        description: 'Delete multiple memories',
+                        options: [
+                            { name: '--ids', description: 'Comma-separated memory IDs', type: 'string', required: true }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'topic',
+                aliases: ['topics'],
+                description: 'Topic management commands',
+                subcommands: [
+                    {
+                        name: 'list',
+                        description: 'List topics',
+                        options: []
+                    },
+                    {
+                        name: 'create',
+                        description: 'Create a new topic',
+                        options: [
+                            { name: '--name', description: 'Topic name', type: 'string', required: true },
+                            { name: '--description', description: 'Topic description', type: 'string' },
+                            { name: '--color', description: 'Topic color', type: 'string' },
+                            { name: '--icon', description: 'Topic icon', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'get',
+                        description: 'Get a specific topic',
+                        options: [
+                            { name: 'id', description: 'Topic ID', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'update',
+                        description: 'Update an existing topic',
+                        options: [
+                            { name: 'id', description: 'Topic ID', type: 'string', required: true },
+                            { name: '--name', description: 'Topic name', type: 'string' },
+                            { name: '--description', description: 'Topic description', type: 'string' },
+                            { name: '--color', description: 'Topic color', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'delete',
+                        description: 'Delete a topic',
+                        options: [
+                            { name: 'id', description: 'Topic ID', type: 'string', required: true }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'config',
+                description: 'Configuration management',
+                subcommands: [
+                    {
+                        name: 'get',
+                        description: 'Get configuration value',
+                        options: [
+                            { name: 'key', description: 'Configuration key', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'set',
+                        description: 'Set configuration value',
+                        options: [
+                            { name: 'key', description: 'Configuration key', type: 'string', required: true },
+                            { name: 'value', description: 'Configuration value', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'list',
+                        description: 'List all configuration',
+                        options: []
+                    },
+                    {
+                        name: 'reset',
+                        description: 'Reset configuration',
+                        options: [
+                            { name: '--confirm', description: 'Confirm reset', type: 'boolean' }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'api-keys',
+                description: 'API key management',
+                subcommands: [
+                    {
+                        name: 'list',
+                        description: 'List API keys',
+                        options: []
+                    },
+                    {
+                        name: 'create',
+                        description: 'Create a new API key',
+                        options: [
+                            { name: '--name', description: 'API key name', type: 'string', required: true },
+                            { name: '--scope', description: 'API key scope', type: 'string' },
+                            { name: '--expires', description: 'Expiration date', type: 'string' }
+                        ]
+                    },
+                    {
+                        name: 'revoke',
+                        description: 'Revoke an API key',
+                        options: [
+                            { name: 'id', description: 'API key ID', type: 'string', required: true }
+                        ]
+                    },
+                    {
+                        name: 'rotate',
+                        description: 'Rotate an API key',
+                        options: [
+                            { name: 'id', description: 'API key ID', type: 'string', required: true }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'mcp',
+                description: 'Model Context Protocol commands',
+                subcommands: [
+                    {
+                        name: 'status',
+                        description: 'Show MCP server status',
+                        options: []
+                    },
+                    {
+                        name: 'connect',
+                        description: 'Connect to MCP server',
+                        options: [
+                            { name: '--remote', description: 'Use remote server', type: 'boolean' },
+                            { name: '--local', description: 'Use local server', type: 'boolean' }
+                        ]
+                    },
+                    {
+                        name: 'disconnect',
+                        description: 'Disconnect from MCP server',
+                        options: []
+                    },
+                    {
+                        name: 'servers',
+                        description: 'List MCP servers',
+                        options: []
+                    },
+                    {
+                        name: 'tools',
+                        description: 'List available tools',
+                        options: []
+                    },
+                    {
+                        name: 'resources',
+                        description: 'List available resources',
+                        options: []
+                    }
+                ]
+            },
+            {
+                name: 'dashboard',
+                description: 'Dashboard management',
+                subcommands: [
+                    {
+                        name: 'status',
+                        description: 'Check dashboard status',
+                        options: []
+                    },
+                    {
+                        name: 'logs',
+                        description: 'View dashboard logs',
+                        options: []
+                    },
+                    {
+                        name: 'open',
+                        description: 'Open dashboard in browser',
+                        options: []
+                    }
+                ]
+            },
+            {
+                name: 'status',
+                description: 'Show overall system status',
+                subcommands: []
+            },
+            {
+                name: 'health',
+                aliases: ['check'],
+                description: 'Comprehensive system health check',
+                subcommands: []
+            }
+        ],
+        globalOptions: [
+            { name: '--help', description: 'Show help information', type: 'boolean' },
+            { name: '--version', description: 'Show version information', type: 'boolean' },
+            { name: '--verbose', description: 'Enable verbose logging', type: 'boolean' },
+            { name: '--output', description: 'Output format', type: 'choice', choices: ['table', 'json', 'yaml', 'csv'] },
+            { name: '--api-url', description: 'Override API URL', type: 'string' },
+            { name: '--no-mcp', description: 'Disable MCP and use direct API', type: 'boolean' }
+        ],
+        contextualData: {
+            memoryTypes,
+            outputFormats: ['table', 'json', 'yaml', 'csv'],
+            sortOptions: ['created_at', 'updated_at', 'last_accessed', 'access_count'],
+            authMethods: ['vendor_key', 'oauth', 'credentials']
+        }
+    };
+    return completionData;
+}
+export async function completionCommand() {
+    try {
+        const data = await generateCompletionData();
+        console.log(JSON.stringify(data, null, 2));
+    }
+    catch (error) {
+        console.error(chalk.red('✖ Failed to generate completion data:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+export async function installCompletionsCommand() {
+    console.log(chalk.blue.bold('🔧 Installing Shell Completions'));
+    console.log(colors.info('═'.repeat(40)));
+    console.log();
+    console.log(chalk.yellow('📋 Installation Instructions:'));
+    console.log();
+    console.log(chalk.white('Bash:'));
+    console.log(chalk.gray('  # Add to ~/.bashrc or ~/.bash_profile:'));
+    console.log(chalk.cyan('  source <(lanonasis --completion bash)'));
+    console.log();
+    console.log(chalk.white('Zsh:'));
+    console.log(chalk.gray('  # Add to ~/.zshrc:'));
+    console.log(chalk.cyan('  source <(lanonasis --completion zsh)'));
+    console.log(chalk.gray('  # Or for Oh My Zsh, create ~/.oh-my-zsh/completions/_lanonasis'));
+    console.log();
+    console.log(chalk.white('Fish:'));
+    console.log(chalk.gray('  # Add to ~/.config/fish/config.fish:'));
+    console.log(chalk.cyan('  lanonasis --completion fish | source'));
+    console.log(chalk.gray('  # Or save to ~/.config/fish/completions/lanonasis.fish'));
+    console.log();
+    console.log(colors.info('💡 Completions support all command aliases:'));
+    console.log(chalk.gray('   • lanonasis, onasis, memory, maas'));
+    console.log();
+    console.log(colors.success('✅ Run the appropriate command above for your shell'));
+}

package/dist/commands/guide.d.ts

@@ -0,0 +1,19 @@
+export declare class UserGuidanceSystem {
+    private config;
+    private steps;
+    constructor();
+    private initializeSteps;
+    runGuidedSetup(): Promise<void>;
+    private assessCurrentStatus;
+    private markStepCompleted;
+    private executeStep;
+    private initializeConfig;
+    private setupAuthentication;
+    private verifyConnection;
+    private createFirstMemory;
+    private exploreFeatures;
+    private setupProductivity;
+    private showCompletionSummary;
+}
+export declare function guideCommand(): Promise<void>;
+export declare function quickStartCommand(): Promise<void>;