@lanonasis/cli 2.0.9 → 3.0.2

package/dist/mcp/access-control.js

@@ -0,0 +1,228 @@
+/**
+ * Memory Access Control System
+ * Implements granular permissions and audit logging inspired by mem0's ACL system
+ */
+import { CLIConfig } from '../utils/config.js';
+import { logger } from './logger.js';
+export class MemoryAccessControl {
+    config;
+    accessRules = new Map();
+    accessLogs = [];
+    constructor() {
+        this.config = new CLIConfig();
+    }
+    /**
+     * Check if user has access to create memories in an app
+     */
+    async checkCreateAccess(userId, appId) {
+        try {
+            // Default: users can create memories in their own apps
+            if (await this.isUserApp(userId, appId)) {
+                return true;
+            }
+            // Check explicit permissions
+            const rules = this.getAccessRules(userId, appId);
+            return rules.some(rule => rule.granted &&
+                (rule.permission === 'write' || rule.permission === 'admin') &&
+                (!rule.expires_at || new Date(rule.expires_at) > new Date()));
+        }
+        catch (error) {
+            logger.error('Failed to check create access', { error, userId, appId });
+            return false;
+        }
+    }
+    /**
+     * Check if user has access to read a specific memory
+     */
+    async checkMemoryAccess(memoryId, appId) {
+        try {
+            const memory = await this.getMemoryInfo(memoryId);
+            const currentUserId = await this.getCurrentUserId();
+            if (!memory) {
+                return false;
+            }
+            // Owner always has access
+            if (memory.user_id === currentUserId) {
+                return true;
+            }
+            // Check explicit permissions using current user ID (FIXED)
+            const rules = this.getAccessRules(currentUserId, appId);
+            return rules.some(rule => rule.granted &&
+                (!rule.expires_at || new Date(rule.expires_at) > new Date()) &&
+                (rule.memory_id === memoryId || !rule.memory_id));
+        }
+        catch (error) {
+            logger.error('Failed to check memory access', { error, memoryId, appId });
+            return false;
+        }
+    }
+    /**
+     * Get all memories accessible to a user in an app
+     */
+    async getAccessibleMemories(userId, appId) {
+        try {
+            // Get user's own memories
+            const ownMemories = await this.getUserMemories(userId);
+            // Get memories shared with the user
+            const sharedMemories = await this.getSharedMemories(userId, appId);
+            // Combine and deduplicate
+            const allMemories = [...ownMemories, ...sharedMemories];
+            return allMemories;
+        }
+        catch (error) {
+            logger.error('Failed to get accessible memories', { error, userId, appId });
+            return [];
+        }
+    }
+    /**
+     * Log memory access for audit purposes
+     */
+    async logMemoryAccess(memoryId, appId, accessType, metadata) {
+        try {
+            const userId = await this.getCurrentUserId();
+            const logEntry = {
+                id: this.generateId(),
+                user_id: userId,
+                app_id: appId,
+                memory_id: memoryId,
+                access_type: accessType,
+                timestamp: new Date().toISOString(),
+                success: true,
+                metadata
+            };
+            this.accessLogs.push(logEntry);
+            // In production, this would be persisted to database
+            logger.debug('Memory access logged', logEntry);
+            // Keep only recent logs in memory (last 1000)
+            if (this.accessLogs.length > 1000) {
+                this.accessLogs = this.accessLogs.slice(-1000);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to log memory access', { error, memoryId, appId, accessType });
+        }
+    }
+    /**
+     * Grant access to a memory or app
+     */
+    async grantAccess(userId, appId, permission, memoryId, expiresAt) {
+        const rule = {
+            id: this.generateId(),
+            user_id: userId,
+            app_id: appId,
+            memory_id: memoryId,
+            permission,
+            granted: true,
+            created_at: new Date().toISOString(),
+            expires_at: expiresAt
+        };
+        const key = `${userId}:${appId}`;
+        const existingRules = this.accessRules.get(key) || [];
+        existingRules.push(rule);
+        this.accessRules.set(key, existingRules);
+        logger.info('Access granted', { userId, appId, permission, memoryId });
+    }
+    /**
+     * Revoke access to a memory or app
+     */
+    async revokeAccess(userId, appId, memoryId) {
+        const key = `${userId}:${appId}`;
+        const existingRules = this.accessRules.get(key) || [];
+        const updatedRules = existingRules.map(rule => {
+            if (!memoryId || rule.memory_id === memoryId) {
+                return { ...rule, granted: false };
+            }
+            return rule;
+        });
+        this.accessRules.set(key, updatedRules);
+        logger.info('Access revoked', { userId, appId, memoryId });
+    }
+    /**
+     * Get access logs for audit purposes
+     */
+    getAccessLogs(userId, appId, memoryId, limit = 100) {
+        let logs = this.accessLogs;
+        if (userId) {
+            logs = logs.filter(log => log.user_id === userId);
+        }
+        if (appId) {
+            logs = logs.filter(log => log.app_id === appId);
+        }
+        if (memoryId) {
+            logs = logs.filter(log => log.memory_id === memoryId);
+        }
+        return logs
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+            .slice(0, limit);
+    }
+    /**
+     * Private helper methods
+     */
+    getAccessRules(userId, appId) {
+        const key = `${userId}:${appId}`;
+        return this.accessRules.get(key) || [];
+    }
+    async isUserApp(userId, appId) {
+        // In a real implementation, this would check if the app belongs to the user
+        // For now, assume apps starting with user ID belong to them
+        return appId.startsWith(userId) || appId === 'default';
+    }
+    async getCurrentUserId() {
+        const token = this.config.get('token');
+        if (token && typeof token === 'string') {
+            try {
+                const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+                return payload.sub || payload.user_id || 'anonymous';
+            }
+            catch {
+                return 'anonymous';
+            }
+        }
+        return 'anonymous';
+    }
+    async getMemoryInfo(memoryId) {
+        try {
+            // This would typically fetch from the API
+            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}`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            logger.error('Failed to get memory info', { error, memoryId });
+            return null;
+        }
+    }
+    async getUserMemories(userId) {
+        try {
+            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}`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            return response.data.memories?.map((m) => m.id) || [];
+        }
+        catch (error) {
+            logger.error('Failed to get user memories', { error, userId });
+            return [];
+        }
+    }
+    async getSharedMemories(userId, appId) {
+        // This would implement logic to find memories shared with the user
+        // through explicit permissions or app-level sharing
+        return [];
+    }
+    generateId() {
+        return `acl_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+    }
+}

package/dist/mcp/client/enhanced-client.js

@@ -128,7 +128,7 @@ export class EnhancedMCPClient extends EventEmitter {
         this.transports.set(config.name, transport);
         const client = new Client({
             name: `lanonasis-cli-${config.name}`,
-            version: '2.0.8'
+            version: '3.0.1'
         }, {
             capabilities: {
                 tools: {},

package/dist/mcp/enhanced-server.d.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Enhanced MCP Server - Adopting mem0 OpenMemory architectural patterns
+ * Implements FastMCP-based server with context management and multi-transport support
+ */
+export declare class EnhancedMCPServer {
+    private server;
+    private config;
+    private accessControl;
+    private vectorStore;
+    private stateManager;
+    private context;
+    constructor();
+    private setContext;
+    private getContext;
+    /**
+     * Setup MCP tools with enhanced functionality
+     */
+    private setupTools;
+    private handleCreateMemory;
+    private handleSearchMemories;
+    private handleBulkOperations;
+    /**
+     * Start the enhanced MCP server
+     */
+    start(options?: {
+        transport?: 'stdio' | 'sse';
+        port?: number;
+        verbose?: boolean;
+    }): Promise<void>;
+    /**
+     * Helper methods for memory operations
+     */
+    private createMemoryWithState;
+    private performVectorSearch;
+    private performBulkOperation;
+    private getCurrentUserId;
+}

package/dist/mcp/enhanced-server.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * Enhanced MCP Server - Adopting mem0 OpenMemory architectural patterns
+ * Implements FastMCP-based server with context management and multi-transport support
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CLIConfig } from '../utils/config.js';
+import { logger } from './logger.js';
+import { MemoryAccessControl } from './access-control.js';
+import { LanonasisVectorStore } from './vector-store.js';
+import { MemoryStateManager } from './memory-state.js';
+export class EnhancedMCPServer {
+    server;
+    config;
+    accessControl;
+    vectorStore;
+    stateManager;
+    context = new Map();
+    constructor() {
+        this.server = new Server({
+            name: "enhanced-lanonasis-mcp",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {},
+            },
+        });
+        this.config = new CLIConfig();
+        this.accessControl = new MemoryAccessControl();
+        this.vectorStore = new LanonasisVectorStore();
+        this.stateManager = new MemoryStateManager();
+        this.setupTools();
+    }
+    setContext(sessionId, context) {
+        this.context.set(sessionId, context);
+    }
+    getContext(sessionId) {
+        return this.context.get(sessionId) || {};
+    }
+    /**
+     * Setup MCP tools with enhanced functionality
+     */
+    setupTools() {
+        // Enhanced memory creation with state management
+        this.server.setRequestHandler({ method: "tools/list" }, async () => ({
+            tools: [
+                {
+                    name: "memory_create_memory",
+                    description: "Create a new memory with advanced state management and access control",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            title: { type: "string", description: "Memory title" },
+                            content: { type: "string", description: "Memory content" },
+                            memory_type: { type: "string", enum: ["context", "fact", "preference", "workflow"], default: "context" },
+                            tags: { type: "array", items: { type: "string" }, description: "Memory tags" },
+                            app_id: { type: "string", description: "Application identifier" },
+                            metadata: { type: "object", description: "Additional metadata" }
+                        },
+                        required: ["content"]
+                    }
+                },
+                {
+                    name: "memory_search_memories",
+                    description: "Search memories with advanced filtering and access control",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query" },
+                            limit: { type: "number", default: 10, description: "Maximum results" },
+                            threshold: { type: "number", default: 0.7, description: "Similarity threshold" },
+                            app_id: { type: "string", description: "Filter by application" },
+                            category: { type: "string", description: "Filter by category" }
+                        },
+                        required: ["query"]
+                    }
+                },
+                {
+                    name: "memory_bulk_operations",
+                    description: "Perform bulk operations on memories (pause, delete, archive)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            operation: { type: "string", enum: ["pause", "delete", "archive"] },
+                            category: { type: "string", description: "Filter by category" },
+                            app_id: { type: "string", description: "Filter by application" },
+                            before: { type: "string", description: "Filter memories before date (ISO)" },
+                            memory_ids: { type: "array", items: { type: "string" }, description: "Specific memory IDs" }
+                        },
+                        required: ["operation"]
+                    }
+                }
+            ]
+        }));
+        this.server.setRequestHandler({ method: "tools/call" }, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "memory_create_memory":
+                        return await this.handleCreateMemory(args);
+                    case "memory_search_memories":
+                        return await this.handleSearchMemories(args);
+                    case "memory_bulk_operations":
+                        return await this.handleBulkOperations(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                logger.error(`Tool execution failed: ${name}`, { error, args });
+                throw error;
+            }
+        });
+    }
+    async handleCreateMemory(args) {
+        try {
+            const userId = await this.getCurrentUserId();
+            const appId = args.app_id || 'default';
+            // Check access control
+            if (!await this.accessControl.checkCreateAccess(userId, appId)) {
+                throw new Error('Access denied: Cannot create memories in this app');
+            }
+            // Create memory with state management
+            const memory = await this.createMemoryWithState({
+                content: args.content,
+                title: args.title,
+                memory_type: args.memory_type || 'context',
+                tags: args.tags || [],
+                app_id: appId,
+                metadata: args.metadata || {}
+            });
+            // Log access
+            await this.accessControl.logMemoryAccess(memory.id, appId, 'create', {
+                memory_type: args.memory_type,
+                tags: args.tags
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Memory created successfully with ID: ${memory.id}`
+                    }],
+                memory: memory,
+                message: "Memory created successfully with enhanced access control"
+            };
+        }
+        catch (error) {
+            logger.error('Memory creation failed', { error, args });
+            throw error;
+        }
+    }
+    async handleSearchMemories(args) {
+        try {
+            const userId = await this.getCurrentUserId();
+            const appId = args.app_id || 'default';
+            // Get accessible memories
+            const accessibleMemories = await this.accessControl.getAccessibleMemories(userId, appId);
+            // Perform vector search
+            const results = await this.performVectorSearch({
+                query: args.query,
+                limit: args.limit || 10,
+                threshold: args.threshold || 0.7,
+                filter: {
+                    app_id: appId,
+                    memory_ids: accessibleMemories
+                }
+            });
+            // Log access
+            await this.accessControl.logMemoryAccess('search', appId, 'search', {
+                query: args.query,
+                results_count: results.length
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Found ${results.length} memories matching your query`
+                    }],
+                results: results,
+                total: results.length,
+                message: `Found ${results.length} memories`
+            };
+        }
+        catch (error) {
+            logger.error('Memory search failed', { error, args });
+            throw error;
+        }
+    }
+    async handleBulkOperations(args) {
+        try {
+            const userId = await this.getCurrentUserId();
+            const appId = args.app_id || 'default';
+            // Get accessible memories
+            const accessibleMemories = await this.accessControl.getAccessibleMemories(userId, appId);
+            // Filter memories based on criteria
+            let targetMemories = accessibleMemories;
+            if (args.memory_ids) {
+                targetMemories = args.memory_ids.filter(id => accessibleMemories.includes(id));
+            }
+            // Perform bulk operation
+            const results = await this.performBulkOperation({
+                operation: args.operation,
+                memory_ids: targetMemories,
+                metadata: {
+                    user_id: userId,
+                    app_id: appId,
+                    timestamp: new Date().toISOString()
+                }
+            });
+            // Log bulk access
+            await this.accessControl.logMemoryAccess('bulk', appId, args.operation, {
+                operation: args.operation,
+                affected_count: results.length
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Bulk ${args.operation} completed on ${results.length} memories`
+                    }],
+                results,
+                affected_count: results.length,
+                message: `Bulk ${args.operation} completed on ${results.length} memories`
+            };
+        }
+        catch (error) {
+            logger.error('Bulk operation failed', { error, args });
+            throw error;
+        }
+    }
+    /**
+     * Start the enhanced MCP server
+     */
+    async start(options = {}) {
+        const { transport = 'stdio', port = 3001, verbose = false } = options;
+        try {
+            // Initialize components
+            await this.config.init();
+            await this.vectorStore.initialize();
+            await this.stateManager.initialize();
+            if (verbose) {
+                logger.info('Starting Enhanced MCP Server', { transport, port });
+            }
+            // Use stdio transport (SSE not available in current MCP SDK)
+            const stdioTransport = new StdioServerTransport();
+            await this.server.connect(stdioTransport);
+            logger.info('Enhanced MCP Server running on stdio transport');
+        }
+        catch (error) {
+            logger.error('Failed to start Enhanced MCP Server', { error });
+            throw error;
+        }
+    }
+    /**
+     * Helper methods for memory operations
+     */
+    async createMemoryWithState(data) {
+        // Mock implementation - in production this would use the actual state manager
+        return {
+            id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+            content: data.content,
+            title: data.title,
+            memory_type: data.memory_type,
+            tags: data.tags,
+            app_id: data.app_id,
+            metadata: data.metadata,
+            created_at: new Date().toISOString(),
+            state: 'active'
+        };
+    }
+    async performVectorSearch(params) {
+        // Mock implementation - in production this would use the actual vector store
+        return [
+            {
+                id: `mem_${Date.now()}`,
+                content: `Mock result for query: ${params.query}`,
+                score: 0.85,
+                metadata: { app_id: params.filter?.app_id }
+            }
+        ];
+    }
+    async performBulkOperation(params) {
+        // Mock implementation - in production this would use the actual state manager
+        return params.memory_ids.map((id) => ({
+            memory_id: id,
+            operation: params.operation,
+            success: true,
+            timestamp: new Date().toISOString()
+        }));
+    }
+    async getCurrentUserId() {
+        const token = this.config.get('token');
+        if (token && typeof token === 'string') {
+            try {
+                const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+                return payload.sub || payload.user_id || 'anonymous';
+            }
+            catch (error) {
+                logger.error('Failed to decode token', { error });
+            }
+        }
+        return 'anonymous';
+    }
+}
+/**
+ * Main function to start the server
+ */
+async function main() {
+    const server = new EnhancedMCPServer();
+    const args = process.argv.slice(2);
+    const options = {
+        transport: args.includes('--sse') ? 'sse' : 'stdio',
+        port: parseInt(args.find(arg => arg.startsWith('--port='))?.split('=')[1] || '3001'),
+        verbose: args.includes('--verbose') || args.includes('-v')
+    };
+    await server.start(options);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(console.error);
+}

package/dist/mcp/logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Enhanced logging system for MCP server
+ * Provides structured logging with different levels and contexts
+ */
+export interface LogContext {
+    [key: string]: any;
+}
+export declare class Logger {
+    private defaultContext;
+    private context;
+    constructor(defaultContext?: LogContext);
+    private formatMessage;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    debug(message: string, context?: LogContext): void;
+    setContext(context: LogContext): void;
+    child(context: LogContext): Logger;
+}
+export declare const logger: Logger;

package/dist/mcp/logger.js

@@ -0,0 +1,47 @@
+/**
+ * Enhanced logging system for MCP server
+ * Provides structured logging with different levels and contexts
+ */
+export class Logger {
+    defaultContext;
+    context = {};
+    constructor(defaultContext = {}) {
+        this.defaultContext = defaultContext;
+        this.context = { ...defaultContext };
+    }
+    formatMessage(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const fullContext = { ...this.context, ...context };
+        const logEntry = {
+            timestamp,
+            level,
+            message,
+            ...fullContext
+        };
+        return JSON.stringify(logEntry);
+    }
+    info(message, context) {
+        console.log(this.formatMessage('INFO', message, context));
+    }
+    warn(message, context) {
+        console.warn(this.formatMessage('WARN', message, context));
+    }
+    error(message, context) {
+        console.error(this.formatMessage('ERROR', message, context));
+    }
+    debug(message, context) {
+        if (process.env.MCP_VERBOSE === 'true') {
+            console.debug(this.formatMessage('DEBUG', message, context));
+        }
+    }
+    setContext(context) {
+        this.context = { ...this.context, ...context };
+    }
+    child(context) {
+        return new Logger({ ...this.context, ...context });
+    }
+}
+export const logger = new Logger({
+    service: 'lanonasis-mcp-server',
+    version: '1.0.0'
+});