@hailer/mcp 1.1.12 → 1.1.13

package/dist/plugins/vipunen/tools.js

@@ -0,0 +1,501 @@
+"use strict";
+/**
+ * Vipunen Tools — Weaviate RAG Knowledge Base
+ *
+ * Tools for querying and managing vectorized documentation in Weaviate.
+ * All tools use contextType: 'none' — they don't need Hailer authentication.
+ *
+ * Auth model:
+ * - Server authenticates to Weaviate with a single WEAVIATE_API_KEY
+ * - Clients authenticate to MCP with their own API keys (VIPUNEN_API_KEYS)
+ * - Each client key belongs to a group: admin, dev, or readonly
+ * - Groups control what operations and collections are accessible
+ *
+ * Permission tiers:
+ * - readonly: 5 tools (query, find-similar, list-sources, count, filter)
+ * - dev: 8 tools (readonly + insert-one, update-chunks, delete-source) — no VipunenConfig writes
+ * - admin: 13 tools (dev + get-schema, export, batch-insert, create-collection, delete-collection)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVipunenTools = createVipunenTools;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../../mcp/tool-registry");
+const schema_doc_json_1 = __importDefault(require("./config/schema-doc.json"));
+const schema_config_json_1 = __importDefault(require("./config/schema-config.json"));
+const response_builder_1 = require("../../mcp/utils/response-builder");
+const client_1 = require("./client");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'vipunen-tools' });
+/** Check if a group can perform write operations on a collection */
+function canWrite(group, collection) {
+    if (group === 'admin')
+        return true;
+    if (group === 'readonly')
+        return false;
+    // Dev: everything except VipunenConfig writes
+    if (group === 'dev')
+        return collection !== 'VipunenConfig';
+    return false;
+}
+/** Check if a group can perform admin operations */
+function canAdmin(group) {
+    return group === 'admin';
+}
+/** Permission error message */
+function permissionError(group, operation, collection) {
+    if (group === 'readonly') {
+        return `Group "readonly" cannot perform write operation "${operation}". Read-only access only.`;
+    }
+    if (group === 'dev' && collection === 'VipunenConfig') {
+        return `Group "dev" has read-only access to VipunenConfig. Use an admin key for writes.`;
+    }
+    return `Group "${group}" cannot perform "${operation}" on collection "${collection}".`;
+}
+/** Admin-only permission error */
+function adminPermissionError(group, operation) {
+    return `Group "${group}" cannot perform admin operation "${operation}". Admin access required.`;
+}
+// ============================================================================
+// Schema loading for create-collection
+// ============================================================================
+function loadSchemaTemplate(schemaType) {
+    return schemaType === 'doc' ? schema_doc_json_1.default : schema_config_json_1.default;
+}
+// ============================================================================
+// Shared where filter schema (reused by query and filter tools)
+// ============================================================================
+const whereFilterSchema = zod_1.z.lazy(() => zod_1.z.object({
+    path: zod_1.z.array(zod_1.z.string()).optional(),
+    operator: zod_1.z.string(),
+    valueText: zod_1.z.string().optional(),
+    valueInt: zod_1.z.number().optional(),
+    valueBoolean: zod_1.z.boolean().optional(),
+    valueDate: zod_1.z.string().optional(),
+    operands: zod_1.z.array(whereFilterSchema).optional(),
+}));
+// ============================================================================
+// Error handling
+// ============================================================================
+function handleToolError(toolName, error) {
+    const message = (0, response_builder_1.getErrorMessage)(error);
+    if (error instanceof client_1.WeaviateAuthError) {
+        logger.warn(`${toolName} auth rejected`, { error: message });
+    }
+    else {
+        logger.error(`${toolName} failed`, { error: message });
+    }
+    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: message }));
+}
+// ============================================================================
+// Tool factory
+// ============================================================================
+function createVipunenTools(client) {
+    const tools = [];
+    // --------------------------------------------------------------------------
+    // vipunen-query — Hybrid search (BM25 + vector)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-query',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Search the Weaviate knowledge base using hybrid search (BM25 + vector). Returns matching documents ranked by relevance.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name (e.g., "InternalDev")'),
+            query: zod_1.z.string().describe('Natural language search query — vector search understands intent, not just keywords'),
+            targetProperties: zod_1.z.array(zod_1.z.string()).describe('Properties to search and return (e.g., ["title", "content", "tags"])'),
+            limit: zod_1.z.number().min(1).max(25).default(5).describe('Max results to return (1-25, default 5)'),
+            where: whereFilterSchema.optional().describe('Weaviate where filter for metadata filtering (e.g., {path: ["scope"], operator: "Equal", valueText: "hailer-mcp"})'),
+        }),
+        async execute(args, _context) {
+            try {
+                logger.debug('vipunen-query', { collection: args.collection, query: args.query.substring(0, 50), limit: args.limit, hasWhere: !!args.where });
+                const result = await client.hybridSearch(args.collection, args.query, args.targetProperties, args.limit, args.where);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ count: result.objects.length, objects: result.objects }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-query', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-find-similar — Pure vector search for dedup detection
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-find-similar',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Find semantically similar documents using pure vector search (nearText). Use for dedup detection — returns objects with similarity scores.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            query: zod_1.z.string().describe('Text to find similar documents for'),
+            limit: zod_1.z.number().min(1).max(25).default(5).describe('Max results (1-25, default 5)'),
+        }),
+        async execute(args, _context) {
+            try {
+                logger.debug('vipunen-find-similar', { collection: args.collection, query: args.query.substring(0, 50), limit: args.limit });
+                const result = await client.nearTextSearch(args.collection, args.query, args.limit);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ count: result.objects.length, objects: result.objects }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-find-similar', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-list-sources — Aggregate chunks by source_file
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-list-sources',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'List all source files in a Weaviate collection with their chunk counts. Useful for understanding what documentation is indexed.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+        }),
+        async execute(args, _context) {
+            try {
+                logger.debug('vipunen-list-sources', { collection: args.collection });
+                const groups = await client.aggregateGroupBy(args.collection, 'source_file');
+                return (0, response_builder_1.textResponse)(JSON.stringify({
+                    totalSources: groups.length,
+                    sources: groups.map(g => ({ source_file: g.value, chunk_count: g.count })),
+                }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-list-sources', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-count — Count objects in a collection
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-count',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Count the total number of objects in a Weaviate collection.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+        }),
+        async execute(args, _context) {
+            try {
+                logger.debug('vipunen-count', { collection: args.collection });
+                const count = await client.countCollection(args.collection);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ collection: args.collection, count }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-count', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-filter — Where filter query (no vector search)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-filter',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Query a Weaviate collection using only where filters (no vector/BM25 search). Works on all collections including non-vectorized ones like VipunenConfig.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            where: whereFilterSchema.describe('Weaviate where filter (e.g., {path: ["scope"], operator: "Equal", valueText: "hailer-mcp"})'),
+            properties: zod_1.z.array(zod_1.z.string()).optional().describe('Properties to return (defaults to all)'),
+            limit: zod_1.z.number().min(1).max(100).default(25).describe('Max results to return (1-100, default 25)'),
+        }),
+        async execute(args, _context) {
+            try {
+                logger.debug('vipunen-filter', { collection: args.collection, limit: args.limit });
+                const result = await client.filterQuery(args.collection, args.where, args.properties, args.limit);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ count: result.objects.length, objects: result.objects }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-filter', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-insert-one — Insert a single object
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-insert-one',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Insert a single document into a Weaviate collection. Returns the created object UUID.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            properties: zod_1.z.record(zod_1.z.any()).describe('Object properties to insert (e.g., { title, content, tags, scope, topic, doc_type })'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canWrite(ctx.group, args.collection)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: permissionError(ctx.group, 'insert', args.collection) }));
+                }
+                logger.debug('vipunen-insert-one', { collection: args.collection, title: args.properties?.title, group: ctx.group });
+                const result = await client.insertObject(args.collection, args.properties);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ uuid: result.uuid }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-insert-one', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-update-chunks — Replace scope+topic+chunk_index chunks
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-update-chunks',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Update documentation chunks by replacing existing objects matching scope + topic + chunk_index. Deletes old chunks then inserts replacements.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            scope: zod_1.z.string().describe('Scope to match (e.g., "hailer-mcp")'),
+            topic: zod_1.z.string().describe('Topic to match (e.g., "overview")'),
+            chunks: zod_1.z.array(zod_1.z.object({
+                chunk_index: zod_1.z.number().describe('Chunk index to replace'),
+                properties: zod_1.z.record(zod_1.z.any()).describe('New properties for this chunk'),
+            })).describe('Chunks to update — each identified by chunk_index'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canWrite(ctx.group, args.collection)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: permissionError(ctx.group, 'update', args.collection) }));
+                }
+                logger.debug('vipunen-update-chunks', {
+                    collection: args.collection,
+                    scope: args.scope,
+                    topic: args.topic,
+                    chunkCount: args.chunks.length,
+                    group: ctx.group,
+                });
+                // Insert first, then delete — minimizes data loss window on failure
+                const results = await Promise.allSettled(args.chunks.map(async (chunk) => {
+                    const newProps = {
+                        ...chunk.properties,
+                        scope: args.scope,
+                        topic: args.topic,
+                        chunk_index: chunk.chunk_index,
+                    };
+                    // Insert the new chunk first
+                    const inserted = await client.insertObject(args.collection, newProps);
+                    // Only delete old chunks after successful insert
+                    try {
+                        await client.deleteByMultipleProperties(args.collection, [
+                            { property: 'scope', value: args.scope },
+                            { property: 'topic', value: args.topic },
+                            { property: 'chunk_index', value: chunk.chunk_index },
+                        ]);
+                    }
+                    catch {
+                        // Old chunk may not exist — that's fine
+                    }
+                    return { chunk_index: chunk.chunk_index, uuid: inserted.uuid };
+                }));
+                const succeeded = results.filter(r => r.status === 'fulfilled').length;
+                const failures = results
+                    .map((r, i) => r.status === 'rejected'
+                    ? { chunk_index: args.chunks[i].chunk_index, error: r.reason?.message || String(r.reason) }
+                    : null)
+                    .filter(Boolean);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ updated: succeeded, failed: failures.length, ...(failures.length > 0 ? { failures } : {}) }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-update-chunks', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-delete-source — Delete all chunks for a source file
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-delete-source',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Delete ALL objects from a collection where source_file matches. Destructive — requires write access to the collection.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            source_file: zod_1.z.string().describe('source_file value to match for deletion'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canWrite(ctx.group, args.collection)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: permissionError(ctx.group, 'delete', args.collection) }));
+                }
+                logger.info('vipunen-delete-source', { collection: args.collection, source_file: args.source_file, group: ctx.group });
+                const result = await client.deleteByProperty(args.collection, 'source_file', args.source_file);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ deleted: result.successful, matched: result.matches }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-delete-source', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-get-schema — Get collection schema (admin only)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-get-schema',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Get the full schema definition of a Weaviate collection. Admin access required.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canAdmin(ctx.group)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: adminPermissionError(ctx.group, 'get-schema') }));
+                }
+                logger.debug('vipunen-get-schema', { collection: args.collection, group: ctx.group });
+                const schema = await client.getCollectionSchema(args.collection);
+                return (0, response_builder_1.textResponse)(JSON.stringify(schema));
+            }
+            catch (error) {
+                return handleToolError('vipunen-get-schema', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-export — Export all objects from a collection (admin only)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-export',
+        group: tool_registry_1.ToolGroup.READ,
+        description: 'Export all objects from a Weaviate collection using cursor-based pagination. Admin access required.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            properties: zod_1.z.array(zod_1.z.string()).optional().describe('Properties to return (defaults to all)'),
+            pageSize: zod_1.z.number().min(1).max(500).default(100).describe('Objects per page (1-500, default 100)'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canAdmin(ctx.group)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: adminPermissionError(ctx.group, 'export') }));
+                }
+                logger.debug('vipunen-export', { collection: args.collection, pageSize: args.pageSize, group: ctx.group });
+                const result = await client.exportCollection(args.collection, args.properties, args.pageSize);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ collection: args.collection, count: result.totalCount, objects: result.objects }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-export', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-batch-insert — Batch insert objects (admin only)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-batch-insert',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Insert multiple objects into a Weaviate collection in batches. Admin access required.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name'),
+            objects: zod_1.z.array(zod_1.z.record(zod_1.z.any())).describe('Array of objects to insert (each is a properties object)'),
+            batchSize: zod_1.z.number().min(1).max(100).default(20).describe('Objects per batch (1-100, default 20)'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canAdmin(ctx.group)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: adminPermissionError(ctx.group, 'batch-insert') }));
+                }
+                logger.debug('vipunen-batch-insert', { collection: args.collection, count: args.objects.length, batchSize: args.batchSize, group: ctx.group });
+                const result = await client.batchInsert(args.collection, args.objects, args.batchSize);
+                return (0, response_builder_1.textResponse)(JSON.stringify(result));
+            }
+            catch (error) {
+                return handleToolError('vipunen-batch-insert', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-create-collection — Create a collection (admin only)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-create-collection',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Create a new Weaviate collection with a predefined schema template. Idempotent — returns existing collection info if already present. Admin access required.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Collection name (must start with uppercase, e.g., "MyDocs")'),
+            schema: zod_1.z.enum(['doc', 'config']).default('doc').describe('Schema template: "doc" (text2vec-transformers vectorizer) or "config" (no vectorizer)'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canAdmin(ctx.group)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: adminPermissionError(ctx.group, 'create-collection') }));
+                }
+                logger.info('vipunen-create-collection', { collection: args.collection, schema: args.schema, group: ctx.group });
+                const schemaTemplate = loadSchemaTemplate(args.schema);
+                const result = await client.createCollection(args.collection, schemaTemplate);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ collection: args.collection, created: result.created, objectCount: result.objectCount }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-create-collection', error);
+            }
+        },
+    });
+    // --------------------------------------------------------------------------
+    // vipunen-delete-collection — Delete a collection (admin only)
+    // --------------------------------------------------------------------------
+    tools.push({
+        name: 'vipunen-delete-collection',
+        group: tool_registry_1.ToolGroup.WRITE,
+        description: 'Delete an entire Weaviate collection and all its objects. DESTRUCTIVE. Admin access required.',
+        contextType: 'none',
+        schema: zod_1.z.object({
+            collection: zod_1.z.string().describe('Weaviate collection name to delete'),
+        }),
+        async execute(args, context) {
+            try {
+                const ctx = context;
+                if (!ctx?.group) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: 'Missing Vipunen group context' }));
+                }
+                if (!canAdmin(ctx.group)) {
+                    return (0, response_builder_1.errorResponse)(JSON.stringify({ error: adminPermissionError(ctx.group, 'delete-collection') }));
+                }
+                logger.info('vipunen-delete-collection', { collection: args.collection, group: ctx.group });
+                const result = await client.deleteCollection(args.collection);
+                return (0, response_builder_1.textResponse)(JSON.stringify({ collection: args.collection, deleted: result.deleted }));
+            }
+            catch (error) {
+                return handleToolError('vipunen-delete-collection', error);
+            }
+        },
+    });
+    return tools;
+}
+//# sourceMappingURL=tools.js.map

package/dist/stdio-server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+import { ToolRegistry } from './mcp/tool-registry';
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+export declare function startStdioServer(toolRegistry: ToolRegistry): Promise<void>;
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Stdio MCP Server for Claude Desktop
+ *
+ * Uses @modelcontextprotocol/sdk with StdioServerTransport for
+ * JSON-RPC communication via stdin/stdout.
+ *
+ * This is the entry point when running as Claude Desktop MCP connector.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStdioServer = startStdioServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_1 = require("./lib/logger");
+const tool_registry_1 = require("./mcp/tool-registry");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const config_1 = require("./config");
+const logger = (0, logger_1.createLogger)({ component: 'stdio-server' });
+/**
+ * Start the stdio MCP server with all registered tools
+ */
+async function startStdioServer(toolRegistry) {
+    logger.info('Starting stdio MCP server for Claude Desktop');
+    // Get API key from environment (set in Claude Desktop config)
+    const apiKey = process.env.MCP_CLIENT_API_KEY;
+    if (!apiKey) {
+        logger.error('MCP_CLIENT_API_KEY environment variable is required for stdio mode');
+        process.exit(1);
+    }
+    // Create MCP server
+    const server = new mcp_js_1.McpServer({
+        name: 'hailer-mcp-server',
+        version: '1.0.0',
+    });
+    // Get tool definitions (filtered by allowed groups, excluding NUCLEAR unless enabled)
+    const allowedGroups = config_1.environment.ENABLE_NUCLEAR_TOOLS
+        ? [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND, tool_registry_1.ToolGroup.NUCLEAR]
+        : [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND];
+    const toolDefinitions = toolRegistry.getToolDefinitions({ allowedGroups });
+    logger.info('Registering tools for stdio server', {
+        toolCount: toolDefinitions.length,
+        allowedGroups,
+    });
+    // Register each tool with the MCP server
+    for (const toolDef of toolDefinitions) {
+        server.tool(toolDef.name, toolDef.description, toolDef.inputSchema.properties ? toolDef.inputSchema : { type: 'object', properties: {} }, async (args) => {
+            const startTime = Date.now();
+            logger.debug('Tool call received', { toolName: toolDef.name, args });
+            try {
+                // Get user context (cached)
+                const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+                // Execute the tool
+                const result = await toolRegistry.executeTool(toolDef.name, args, userContext);
+                const duration = Date.now() - startTime;
+                logger.info('Tool call completed', { toolName: toolDef.name, duration });
+                // Handle different result formats
+                if (result && typeof result === 'object' && 'content' in result) {
+                    // Result is already in MCP format { content: [...] }
+                    return result;
+                }
+                // Wrap result in MCP format
+                return {
+                    content: [{
+                            type: 'text',
+                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error('Tool call failed', error, { toolName: toolDef.name, duration });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+        });
+    }
+    // Create stdio transport
+    const transport = new stdio_js_1.StdioServerTransport();
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        logger.info('Received SIGINT, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        logger.info('Received SIGTERM, shutting down stdio server');
+        await server.close();
+        process.exit(0);
+    });
+    // Connect and start serving
+    logger.info('Connecting stdio transport');
+    await server.connect(transport);
+    logger.info('Stdio MCP server is running');
+}
+//# sourceMappingURL=stdio-server.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "1.1.12",
+  "version": "1.1.13",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
@@ -44,6 +44,7 @@
     "form-data": "^4.0.4",
     "openai": "^5.5.1",
     "sharp": "^0.34.5",
+    "tar": "^7.5.13",
     "typescript-language-server": "^5.1.3",
     "zod": "^3.24.1"
   },