@lanonasis/cli 3.2.14 → 3.4.15

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

@@ -1,911 +0,0 @@
-"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);
-    });
-}