@lanonasis/cli 3.1.13 → 3.3.15

package/dist/mcp/server/mcp/server/lanonasis-server.js

@@ -0,0 +1,911 @@
+"use strict";
+/**
+ * Lanonasis MCP Server Implementation
+ * Provides MCP protocol access to Lanonasis MaaS functionality
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanonasisMCPServer = void 0;
+var index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+var stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+var config_js_1 = require("../../utils/config.js");
+var api_js_1 = require("../../utils/api.js");
+var chalk_1 = require("chalk");
+var LanonasisMCPServer = /** @class */ (function () {
+    function LanonasisMCPServer(options) {
+        if (options === void 0) { options = {}; }
+        this.transport = null;
+        this.options = options;
+        // Initialize server with metadata
+        this.server = new index_js_1.Server({
+            name: options.name || "lanonasis-maas-server",
+            version: options.version || "3.0.1"
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {}
+            }
+        });
+        // Initialize config and API client
+        this.config = new config_js_1.CLIConfig();
+        this.apiClient = new api_js_1.APIClient();
+        // Note: registerTools is now async and called in initialize()
+        // Setup error handling
+        this.setupErrorHandling();
+    }
+    /**
+     * Initialize the server
+     */
+    LanonasisMCPServer.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var apiUrl, token;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // Initialize configuration
+                    return [4 /*yield*/, this.config.init()];
+                    case 1:
+                        // Initialize configuration
+                        _a.sent();
+                        if (!this.options.apiUrl) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.config.setApiUrl(this.options.apiUrl)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!this.options.token) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.config.setToken(this.options.token)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        apiUrl = this.config.getApiUrl();
+                        token = this.config.getToken();
+                        if (apiUrl) {
+                            this.apiClient = new api_js_1.APIClient();
+                            // APIClient will use the config internally
+                        }
+                        // Register tools, resources, and prompts after config is loaded
+                        return [4 /*yield*/, this.registerTools()];
+                    case 6:
+                        // Register tools, resources, and prompts after config is loaded
+                        _a.sent();
+                        return [4 /*yield*/, this.registerResources()];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, this.registerPrompts()];
+                    case 8:
+                        _a.sent();
+                        if (this.options.verbose) {
+                            console.log(chalk_1.default.cyan('🚀 Lanonasis MCP Server initialized'));
+                            console.log(chalk_1.default.gray("API URL: ".concat(apiUrl)));
+                            console.log(chalk_1.default.gray("Authenticated: ".concat(token ? 'Yes' : 'No')));
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register MCP tools
+     */
+    LanonasisMCPServer.prototype.registerTools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, ListToolsRequestSchema, CallToolRequestSchema;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('@modelcontextprotocol/sdk/types.js'); })];
+                    case 1:
+                        _a = _b.sent(), ListToolsRequestSchema = _a.ListToolsRequestSchema, CallToolRequestSchema = _a.CallToolRequestSchema;
+                        // List available tools
+                        this.server.setRequestHandler(ListToolsRequestSchema, function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, ({
+                                        tools: [
+                                            // Memory tools
+                                            {
+                                                name: 'memory_create',
+                                                description: 'Create a new memory entry',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        title: {
+                                                            type: 'string',
+                                                            description: 'Memory title'
+                                                        },
+                                                        content: {
+                                                            type: 'string',
+                                                            description: 'Memory content'
+                                                        },
+                                                        memory_type: {
+                                                            type: 'string',
+                                                            enum: ['context', 'reference', 'note'],
+                                                            default: 'context',
+                                                            description: 'Type of memory'
+                                                        },
+                                                        tags: {
+                                                            type: 'array',
+                                                            items: { type: 'string' },
+                                                            description: 'Optional tags for the memory'
+                                                        }
+                                                    },
+                                                    required: ['title', 'content']
+                                                }
+                                            },
+                                            {
+                                                name: 'memory_search',
+                                                description: 'Search memories using semantic search',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        query: {
+                                                            type: 'string',
+                                                            description: 'Search query'
+                                                        },
+                                                        limit: {
+                                                            type: 'number',
+                                                            default: 10,
+                                                            description: 'Maximum number of results'
+                                                        },
+                                                        threshold: {
+                                                            type: 'number',
+                                                            minimum: 0,
+                                                            maximum: 1,
+                                                            default: 0.7,
+                                                            description: 'Similarity threshold'
+                                                        }
+                                                    },
+                                                    required: ['query']
+                                                }
+                                            },
+                                            {
+                                                name: 'memory_list',
+                                                description: 'List all memory entries',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        limit: {
+                                                            type: 'number',
+                                                            default: 20,
+                                                            description: 'Maximum number of results'
+                                                        },
+                                                        offset: {
+                                                            type: 'number',
+                                                            default: 0,
+                                                            description: 'Pagination offset'
+                                                        },
+                                                        topic_id: {
+                                                            type: 'string',
+                                                            description: 'Filter by topic ID'
+                                                        }
+                                                    }
+                                                }
+                                            },
+                                            {
+                                                name: 'memory_get',
+                                                description: 'Get a specific memory by ID',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        memory_id: {
+                                                            type: 'string',
+                                                            description: 'Memory ID'
+                                                        }
+                                                    },
+                                                    required: ['memory_id']
+                                                }
+                                            },
+                                            {
+                                                name: 'memory_update',
+                                                description: 'Update an existing memory',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        memory_id: {
+                                                            type: 'string',
+                                                            description: 'Memory ID'
+                                                        },
+                                                        title: {
+                                                            type: 'string',
+                                                            description: 'New title (optional)'
+                                                        },
+                                                        content: {
+                                                            type: 'string',
+                                                            description: 'New content (optional)'
+                                                        },
+                                                        tags: {
+                                                            type: 'array',
+                                                            items: { type: 'string' },
+                                                            description: 'New tags (optional)'
+                                                        }
+                                                    },
+                                                    required: ['memory_id']
+                                                }
+                                            },
+                                            {
+                                                name: 'memory_delete',
+                                                description: 'Delete a memory',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        memory_id: {
+                                                            type: 'string',
+                                                            description: 'Memory ID'
+                                                        }
+                                                    },
+                                                    required: ['memory_id']
+                                                }
+                                            },
+                                            // Topic tools
+                                            {
+                                                name: 'topic_create',
+                                                description: 'Create a new topic',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        name: {
+                                                            type: 'string',
+                                                            description: 'Topic name'
+                                                        },
+                                                        description: {
+                                                            type: 'string',
+                                                            description: 'Topic description'
+                                                        }
+                                                    },
+                                                    required: ['name']
+                                                }
+                                            },
+                                            {
+                                                name: 'topic_list',
+                                                description: 'List all topics',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        limit: {
+                                                            type: 'number',
+                                                            default: 20
+                                                        }
+                                                    }
+                                                }
+                                            },
+                                            // API Key tools
+                                            {
+                                                name: 'apikey_create',
+                                                description: 'Create a new API key',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        name: {
+                                                            type: 'string',
+                                                            description: 'API key name'
+                                                        },
+                                                        permissions: {
+                                                            type: 'array',
+                                                            items: {
+                                                                type: 'string',
+                                                                enum: ['read', 'write', 'delete']
+                                                            },
+                                                            default: ['read']
+                                                        }
+                                                    },
+                                                    required: ['name']
+                                                }
+                                            },
+                                            {
+                                                name: 'apikey_list',
+                                                description: 'List all API keys',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {}
+                                                }
+                                            },
+                                            // System tools
+                                            {
+                                                name: 'system_health',
+                                                description: 'Check system health status',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        verbose: {
+                                                            type: 'boolean',
+                                                            default: false,
+                                                            description: 'Include detailed diagnostics'
+                                                        }
+                                                    }
+                                                }
+                                            },
+                                            {
+                                                name: 'system_config',
+                                                description: 'Get or update system configuration',
+                                                inputSchema: {
+                                                    type: 'object',
+                                                    properties: {
+                                                        action: {
+                                                            type: 'string',
+                                                            enum: ['get', 'set'],
+                                                            default: 'get'
+                                                        },
+                                                        key: {
+                                                            type: 'string',
+                                                            description: 'Configuration key'
+                                                        },
+                                                        value: {
+                                                            type: 'string',
+                                                            description: 'Configuration value (for set action)'
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        ]
+                                    })];
+                            });
+                        }); });
+                        // Tool call handler (CallToolRequestSchema already imported above)
+                        this.server.setRequestHandler(CallToolRequestSchema, function (request) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, name, args, result, error_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = request.params, name = _a.name, args = _a.arguments;
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.handleToolCall(name, args)];
+                                    case 2:
+                                        result = _b.sent();
+                                        return [2 /*return*/, {
+                                                content: [
+                                                    {
+                                                        type: 'text',
+                                                        text: JSON.stringify(result, null, 2)
+                                                    }
+                                                ]
+                                            }];
+                                    case 3:
+                                        error_1 = _b.sent();
+                                        return [2 /*return*/, {
+                                                content: [
+                                                    {
+                                                        type: 'text',
+                                                        text: "Error: ".concat(error_1 instanceof Error ? error_1.message : 'Unknown error')
+                                                    }
+                                                ],
+                                                isError: true
+                                            }];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register MCP resources
+     */
+    LanonasisMCPServer.prototype.registerResources = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, ListResourcesRequestSchema, ReadResourceRequestSchema;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('@modelcontextprotocol/sdk/types.js'); })];
+                    case 1:
+                        _a = _b.sent(), ListResourcesRequestSchema = _a.ListResourcesRequestSchema, ReadResourceRequestSchema = _a.ReadResourceRequestSchema;
+                        this.server.setRequestHandler(ListResourcesRequestSchema, function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, ({
+                                        resources: [
+                                            {
+                                                uri: 'memory://recent',
+                                                name: 'Recent Memories',
+                                                description: 'List of recently created or updated memories',
+                                                mimeType: 'application/json'
+                                            },
+                                            {
+                                                uri: 'memory://search',
+                                                name: 'Memory Search',
+                                                description: 'Search interface for memories',
+                                                mimeType: 'application/json'
+                                            },
+                                            {
+                                                uri: 'config://current',
+                                                name: 'Current Configuration',
+                                                description: 'Current CLI configuration settings',
+                                                mimeType: 'application/json'
+                                            },
+                                            {
+                                                uri: 'stats://usage',
+                                                name: 'Usage Statistics',
+                                                description: 'Memory usage and API statistics',
+                                                mimeType: 'application/json'
+                                            }
+                                        ]
+                                    })];
+                            });
+                        }); });
+                        this.server.setRequestHandler(ReadResourceRequestSchema, function (request) { return __awaiter(_this, void 0, void 0, function () {
+                            var uri, content, error_2;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        uri = request.params.uri;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.handleResourceRead(uri)];
+                                    case 2:
+                                        content = _a.sent();
+                                        return [2 /*return*/, {
+                                                contents: [
+                                                    {
+                                                        uri: uri,
+                                                        mimeType: 'application/json',
+                                                        text: JSON.stringify(content, null, 2)
+                                                    }
+                                                ]
+                                            }];
+                                    case 3:
+                                        error_2 = _a.sent();
+                                        throw new Error("Failed to read resource ".concat(uri, ": ").concat(error_2));
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Register MCP prompts
+     */
+    LanonasisMCPServer.prototype.registerPrompts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, ListPromptsRequestSchema, GetPromptRequestSchema;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('@modelcontextprotocol/sdk/types.js'); })];
+                    case 1:
+                        _a = _b.sent(), ListPromptsRequestSchema = _a.ListPromptsRequestSchema, GetPromptRequestSchema = _a.GetPromptRequestSchema;
+                        this.server.setRequestHandler(ListPromptsRequestSchema, function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, ({
+                                        prompts: [
+                                            {
+                                                name: 'create_memory',
+                                                description: 'Interactive prompt to create a new memory',
+                                                arguments: [
+                                                    {
+                                                        name: 'title',
+                                                        description: 'Initial title for the memory',
+                                                        required: false
+                                                    }
+                                                ]
+                                            },
+                                            {
+                                                name: 'search_memories',
+                                                description: 'Interactive prompt to search memories',
+                                                arguments: [
+                                                    {
+                                                        name: 'query',
+                                                        description: 'Initial search query',
+                                                        required: false
+                                                    }
+                                                ]
+                                            },
+                                            {
+                                                name: 'organize_memories',
+                                                description: 'Interactive prompt to organize memories into topics',
+                                                arguments: []
+                                            }
+                                        ]
+                                    })];
+                            });
+                        }); });
+                        this.server.setRequestHandler(GetPromptRequestSchema, function (request) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a, name, args, prompts, prompt;
+                            return __generator(this, function (_b) {
+                                _a = request.params, name = _a.name, args = _a.arguments;
+                                prompts = {
+                                    create_memory: {
+                                        description: 'Create a new memory entry',
+                                        messages: [
+                                            {
+                                                role: 'user',
+                                                content: {
+                                                    type: 'text',
+                                                    text: "Please provide the following information for the new memory:\n                \nTitle: ".concat((args === null || args === void 0 ? void 0 : args.title) || '[Enter a descriptive title]', "\nContent: [Enter the memory content]\nType: [context/reference/note]\nTags: [Optional comma-separated tags]")
+                                                }
+                                            }
+                                        ]
+                                    },
+                                    search_memories: {
+                                        description: 'Search through your memories',
+                                        messages: [
+                                            {
+                                                role: 'user',
+                                                content: {
+                                                    type: 'text',
+                                                    text: "What would you like to search for in your memories?\n                \nQuery: ".concat((args === null || args === void 0 ? void 0 : args.query) || '[Enter search terms]', "\nLimit: [Number of results, default 10]\nThreshold: [Similarity threshold 0-1, default 0.7]")
+                                                }
+                                            }
+                                        ]
+                                    },
+                                    organize_memories: {
+                                        description: 'Organize memories into topics',
+                                        messages: [
+                                            {
+                                                role: 'user',
+                                                content: {
+                                                    type: 'text',
+                                                    text: "Let's organize your memories into topics.\n                \nWould you like to:\n1. Create a new topic\n2. Move memories to existing topics\n3. Review uncategorized memories\n4. Merge similar topics\n\nPlease choose an option (1-4):"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                };
+                                prompt = prompts[name];
+                                if (!prompt) {
+                                    throw new Error("Unknown prompt: ".concat(name));
+                                }
+                                return [2 /*return*/, prompt];
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Handle tool calls
+     */
+    LanonasisMCPServer.prototype.handleToolCall = function (name, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this.apiClient) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        _a = name;
+                        switch (_a) {
+                            case 'memory_create': return [3 /*break*/, 3];
+                            case 'memory_search': return [3 /*break*/, 5];
+                            case 'memory_list': return [3 /*break*/, 7];
+                            case 'memory_get': return [3 /*break*/, 9];
+                            case 'memory_update': return [3 /*break*/, 11];
+                            case 'memory_delete': return [3 /*break*/, 13];
+                            case 'topic_create': return [3 /*break*/, 15];
+                            case 'topic_list': return [3 /*break*/, 17];
+                            case 'apikey_create': return [3 /*break*/, 19];
+                            case 'apikey_list': return [3 /*break*/, 20];
+                            case 'system_health': return [3 /*break*/, 21];
+                            case 'system_config': return [3 /*break*/, 23];
+                        }
+                        return [3 /*break*/, 25];
+                    case 3: return [4 /*yield*/, this.apiClient.createMemory(args)];
+                    case 4: return [2 /*return*/, _b.sent()];
+                    case 5: return [4 /*yield*/, this.apiClient.searchMemories(args.query, {
+                            limit: args.limit,
+                            threshold: args.threshold
+                        })];
+                    case 6: return [2 /*return*/, _b.sent()];
+                    case 7: return [4 /*yield*/, this.apiClient.getMemories({
+                            limit: args.limit,
+                            offset: args.offset,
+                            topic_id: args.topic_id
+                        })];
+                    case 8: return [2 /*return*/, _b.sent()];
+                    case 9: return [4 /*yield*/, this.apiClient.getMemory(args.memory_id)];
+                    case 10: return [2 /*return*/, _b.sent()];
+                    case 11: return [4 /*yield*/, this.apiClient.updateMemory(args.memory_id, args)];
+                    case 12: return [2 /*return*/, _b.sent()];
+                    case 13: return [4 /*yield*/, this.apiClient.deleteMemory(args.memory_id)];
+                    case 14: return [2 /*return*/, _b.sent()];
+                    case 15: return [4 /*yield*/, this.apiClient.createTopic(args)];
+                    case 16: return [2 /*return*/, _b.sent()];
+                    case 17: return [4 /*yield*/, this.apiClient.getTopics()];
+                    case 18: return [2 /*return*/, _b.sent()];
+                    case 19: 
+                    // API keys not directly supported in current APIClient
+                    return [2 /*return*/, { error: 'API key creation not yet implemented' }];
+                    case 20: 
+                    // API keys not directly supported in current APIClient
+                    return [2 /*return*/, { error: 'API key listing not yet implemented' }];
+                    case 21: return [4 /*yield*/, this.handleSystemHealth(args.verbose)];
+                    case 22: return [2 /*return*/, _b.sent()];
+                    case 23: return [4 /*yield*/, this.handleSystemConfig(args)];
+                    case 24: return [2 /*return*/, _b.sent()];
+                    case 25: throw new Error("Unknown tool: ".concat(name));
+                }
+            });
+        });
+    };
+    /**
+     * Handle resource reads
+     */
+    LanonasisMCPServer.prototype.handleResourceRead = function (uri) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, protocol, path, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = uri.split('://'), protocol = _a[0], path = _a[1];
+                        _b = protocol;
+                        switch (_b) {
+                            case 'memory': return [3 /*break*/, 1];
+                            case 'config': return [3 /*break*/, 5];
+                            case 'stats': return [3 /*break*/, 10];
+                        }
+                        return [3 /*break*/, 11];
+                    case 1:
+                        if (!(path === 'recent')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.apiClient.getMemories({ limit: 10 })];
+                    case 2: return [2 /*return*/, _d.sent()];
+                    case 3:
+                        if (path === 'search') {
+                            return [2 /*return*/, {
+                                    message: 'Use memory_search tool to search memories',
+                                    example: { query: 'your search query', limit: 10 }
+                                }];
+                        }
+                        _d.label = 4;
+                    case 4: return [3 /*break*/, 11];
+                    case 5:
+                        if (!(path === 'current')) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.config.init()];
+                    case 6:
+                        _d.sent();
+                        _c = {
+                            apiUrl: this.config.getApiUrl()
+                        };
+                        return [4 /*yield*/, this.config.isAuthenticated()];
+                    case 7:
+                        _c.authenticated = _d.sent();
+                        return [4 /*yield*/, this.config.getCurrentUser()];
+                    case 8: return [2 /*return*/, (_c.user = _d.sent(),
+                            _c)];
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (path === 'usage') {
+                            // TODO: Implement actual stats collection
+                            return [2 /*return*/, {
+                                    totalMemories: 0,
+                                    totalTopics: 0,
+                                    apiCallsToday: 0,
+                                    lastSync: new Date().toISOString()
+                                }];
+                        }
+                        return [3 /*break*/, 11];
+                    case 11: throw new Error("Unknown resource: ".concat(uri));
+                }
+            });
+        });
+    };
+    /**
+     * Handle system health check
+     */
+    LanonasisMCPServer.prototype.handleSystemHealth = function (verbose) {
+        return __awaiter(this, void 0, void 0, function () {
+            var health, _a, apiHealth, error_3;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        health = {
+                            status: 'healthy',
+                            server: this.options.name || 'lanonasis-maas-server',
+                            version: this.options.version || '3.0.1',
+                            timestamp: new Date().toISOString()
+                        };
+                        if (!verbose) return [3 /*break*/, 5];
+                        _a = health;
+                        _b = {
+                            url: this.config.getApiUrl()
+                        };
+                        return [4 /*yield*/, this.config.isAuthenticated()];
+                    case 1:
+                        _a.api = (_b.authenticated = _c.sent(),
+                            _b);
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.apiClient.getHealth()];
+                    case 3:
+                        apiHealth = _c.sent();
+                        health.api.status = apiHealth.status;
+                        health.api.version = apiHealth.version;
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_3 = _c.sent();
+                        health.api.status = 'error';
+                        health.api.error = error_3 instanceof Error ? error_3.message : 'Unknown error';
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/, health];
+                }
+            });
+        });
+    };
+    /**
+     * Handle system configuration
+     */
+    LanonasisMCPServer.prototype.handleSystemConfig = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(args.action === 'get')) return [3 /*break*/, 4];
+                        if (!args.key) return [3 /*break*/, 1];
+                        return [2 /*return*/, (_a = {}, _a[args.key] = this.config.get(args.key), _a)];
+                    case 1: 
+                    // Return all config
+                    return [4 /*yield*/, this.config.init()];
+                    case 2:
+                        // Return all config
+                        _b.sent();
+                        return [2 /*return*/, {
+                                apiUrl: this.config.getApiUrl(),
+                                mcpServerUrl: this.config.get('mcpServerUrl'),
+                                mcpUseRemote: this.config.get('mcpUseRemote')
+                            }];
+                    case 3: return [3 /*break*/, 6];
+                    case 4:
+                        if (!(args.action === 'set')) return [3 /*break*/, 6];
+                        if (!args.key || !args.value) {
+                            throw new Error('Key and value required for set action');
+                        }
+                        this.config.set(args.key, args.value);
+                        return [4 /*yield*/, this.config.save()];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                message: "Set ".concat(args.key, " to ").concat(args.value)
+                            }];
+                    case 6: throw new Error('Invalid action');
+                }
+            });
+        });
+    };
+    /**
+     * Setup error handling
+     */
+    LanonasisMCPServer.prototype.setupErrorHandling = function () {
+        var _this = this;
+        process.on('SIGINT', function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log(chalk_1.default.yellow('\n⚠️ Shutting down MCP server...'));
+                        return [4 /*yield*/, this.stop()];
+                    case 1:
+                        _a.sent();
+                        process.exit(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        process.on('uncaughtException', function (error) {
+            console.error(chalk_1.default.red('Uncaught exception:'), error);
+            process.exit(1);
+        });
+        process.on('unhandledRejection', function (reason, promise) {
+            console.error(chalk_1.default.red('Unhandled rejection at:'), promise, 'reason:', reason);
+        });
+    };
+    /**
+     * Start the server
+     */
+    LanonasisMCPServer.prototype.start = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _a.sent();
+                        // Create and connect transport
+                        this.transport = new stdio_js_1.StdioServerTransport();
+                        return [4 /*yield*/, this.server.connect(this.transport)];
+                    case 2:
+                        _a.sent();
+                        if (this.options.verbose) {
+                            console.log(chalk_1.default.green('✅ Lanonasis MCP Server started'));
+                            console.log(chalk_1.default.gray('Waiting for client connections...'));
+                        }
+                        // Keep the process alive
+                        process.stdin.resume();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stop the server
+     */
+    LanonasisMCPServer.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.transport) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.server.close()];
+                    case 1:
+                        _a.sent();
+                        this.transport = null;
+                        _a.label = 2;
+                    case 2:
+                        if (this.options.verbose) {
+                            console.log(chalk_1.default.gray('MCP Server stopped'));
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get server instance (for testing)
+     */
+    LanonasisMCPServer.prototype.getServer = function () {
+        return this.server;
+    };
+    return LanonasisMCPServer;
+}());
+exports.LanonasisMCPServer = LanonasisMCPServer;
+// CLI entry point
+if (import.meta.url === "file://".concat(process.argv[1])) {
+    var server = new LanonasisMCPServer({
+        verbose: process.argv.includes('--verbose'),
+        apiUrl: process.env.LANONASIS_API_URL,
+        token: process.env.LANONASIS_TOKEN
+    });
+    server.start().catch(function (error) {
+        console.error(chalk_1.default.red('Failed to start server:'), error);
+        process.exit(1);
+    });
+}