@hailer/mcp 0.0.1

package/dist/mcp/tool-registry.js

@@ -0,0 +1,306 @@
+"use strict";
+/**
+ * Clean Tool Registry with Dependency Injection
+ *
+ * No singletons, no statics - just clean, explicit tool registration
+ * with per-agent access control via dependency injection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.ToolGroup = void 0;
+const zod_1 = require("zod");
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'tool-registry' });
+/**
+ * Tool groups for access control
+ * READ: Safe read operations (workflows, activities, schemas)
+ * WRITE: Create/update operations (activities, discussions)
+ * PLAYGROUND: Admin/dev tools (workflow/app management)
+ * NUCLEAR: Destructive operations (remove workflows, apps, insights, templates)
+ */
+var ToolGroup;
+(function (ToolGroup) {
+    ToolGroup["READ"] = "read";
+    ToolGroup["WRITE"] = "write";
+    ToolGroup["PLAYGROUND"] = "playground";
+    ToolGroup["NUCLEAR"] = "nuclear";
+})(ToolGroup || (exports.ToolGroup = ToolGroup = {}));
+/**
+ * ToolRegistry - Clean, testable, dependency-injected tool registry
+ *
+ * NO SINGLETON PATTERN - instantiated explicitly and passed through DI
+ */
+class ToolRegistry {
+    tools = new Map();
+    enableNuclearTools;
+    constructor(options = {}) {
+        this.enableNuclearTools = options.enableNuclearTools ?? false;
+        logger.debug('ToolRegistry instance created', {
+            enableNuclearTools: this.enableNuclearTools
+        });
+    }
+    /**
+     * Add a tool to the registry
+     */
+    addTool(tool) {
+        // Short-circuit: Skip NUCLEAR tools when not enabled
+        if (tool.group === ToolGroup.NUCLEAR && !this.enableNuclearTools) {
+            logger.info('Skipping NUCLEAR tool (not enabled)', {
+                name: tool.name,
+                group: tool.group
+            });
+            return;
+        }
+        if (this.tools.has(tool.name)) {
+            logger.warn('Tool already registered, replacing', { name: tool.name });
+        }
+        this.tools.set(tool.name, tool);
+        logger.debug('Tool registered', { name: tool.name, group: tool.group });
+    }
+    /**
+     * Get tool definitions with optional filtering
+     *
+     * @param filter - Optional filter configuration
+     * @param filter.allowedGroups - Filter by tool groups
+     * @param filter.allowedTools - Explicit whitelist of tool names
+     */
+    getToolDefinitions(filter) {
+        let toolsToExpose = Array.from(this.tools.values());
+        if (filter) {
+            if (filter.allowedTools) {
+                // Explicit whitelist by tool name (takes precedence)
+                toolsToExpose = toolsToExpose.filter(t => filter.allowedTools.includes(t.name));
+                logger.debug('Filtered tools by allowedTools', {
+                    count: toolsToExpose.length,
+                    allowedTools: filter.allowedTools
+                });
+            }
+            else if (filter.allowedGroups) {
+                // Filter by tool groups
+                toolsToExpose = toolsToExpose.filter(t => filter.allowedGroups.includes(t.group));
+                logger.debug('Filtered tools by allowedGroups', {
+                    count: toolsToExpose.length,
+                    allowedGroups: filter.allowedGroups
+                });
+            }
+        }
+        return toolsToExpose.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: this.convertZodSchemaToJsonSchema(tool.schema)
+        }));
+    }
+    /**
+     * Get specific tool schema on-demand
+     * Token-efficient: ~200 tokens per tool vs loading all tools upfront
+     */
+    getToolSchema(toolName) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            logger.warn('Tool not found', { toolName });
+            return null;
+        }
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: this.convertZodSchemaToJsonSchema(tool.schema)
+        };
+    }
+    /**
+     * Execute tool with validation
+     */
+    async executeTool(name, args, context) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new Error(`Tool "${name}" not found`);
+        }
+        logger.debug('Executing tool', {
+            name,
+            apiKey: context.apiKey.substring(0, 8) + '...'
+        });
+        // Zod validation
+        try {
+            const validated = tool.schema.parse(args);
+            return await tool.execute(validated, context);
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const errorDetails = error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
+                logger.warn('Tool validation failed', {
+                    toolName: name,
+                    errors: errorDetails,
+                    receivedArgs: JSON.stringify(args)
+                });
+                // Check if tool has a skill hint
+                const hasSkillHint = tool.description.includes('Use Skill');
+                const skillName = hasSkillHint ? tool.description.match(/`([^`]+)-skill`/)?.[1] + '-skill' : null;
+                const errorMessage = `❌ **Validation Error for \`${name}\`**
+
+**Errors:** ${errorDetails}
+
+**You provided:**
+\`\`\`json
+${JSON.stringify(args, null, 2)}
+\`\`\`
+
+${skillName ? `💡 **Next step:** Load the skill first to see correct format and examples:
+\`\`\`
+get_skill({ skillName: "${skillName}" })
+\`\`\`
+
+Then retry \`${name}\` with the correct format from the skill examples.` : `💡 **Next step:** Use \`tools/get_schema\` to see the full schema for \`${name}\`, then retry with correct parameters.`}`;
+                return {
+                    content: [{
+                            type: "text",
+                            text: errorMessage
+                        }]
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get tool metadata (for access control checks)
+     */
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Get total tool count
+     */
+    getToolCount() {
+        return this.tools.size;
+    }
+    /**
+     * Get statistics for monitoring/debugging
+     */
+    getCacheStats() {
+        const byGroup = {
+            [ToolGroup.READ]: 0,
+            [ToolGroup.WRITE]: 0,
+            [ToolGroup.PLAYGROUND]: 0,
+            [ToolGroup.NUCLEAR]: 0
+        };
+        for (const tool of this.tools.values()) {
+            byGroup[tool.group]++;
+        }
+        return {
+            totalTools: this.tools.size,
+            toolNames: Array.from(this.tools.keys()),
+            byGroup
+        };
+    }
+    /**
+     * Convert Zod schema to JSON Schema format (required by MCP protocol)
+     */
+    convertZodSchemaToJsonSchema(zodSchema) {
+        // Handle ZodObject by extracting its shape
+        if (zodSchema._def?.typeName === 'ZodObject') {
+            zodSchema = zodSchema._def.shape();
+        }
+        const properties = {};
+        const required = [];
+        // Handle the schema object
+        for (const [key, value] of Object.entries(zodSchema)) {
+            if (value && typeof value === "object" && "_def" in value) {
+                const zodType = value;
+                const property = this.convertZodTypeToJsonSchema(zodType);
+                // Handle optional vs required - Check for ZodOptional and ZodDefault wrappers
+                const isOptional = zodType._def?.typeName === 'ZodOptional';
+                const hasDefault = zodType._def?.typeName === 'ZodDefault';
+                if (!isOptional && !hasDefault) {
+                    required.push(key);
+                }
+                // Handle default values - Extract from ZodDefault wrapper
+                if (hasDefault && typeof zodType._def?.defaultValue === 'function') {
+                    property.default = zodType._def.defaultValue();
+                }
+                properties[key] = property;
+            }
+        }
+        return {
+            type: "object",
+            properties,
+            required,
+        };
+    }
+    /**
+     * Convert a single Zod type to JSON Schema
+     */
+    convertZodTypeToJsonSchema(zodType) {
+        // Unwrap ZodOptional and ZodDefault wrappers to get the inner type
+        let unwrappedType = zodType;
+        while (unwrappedType._def?.typeName === 'ZodOptional' || unwrappedType._def?.typeName === 'ZodDefault') {
+            unwrappedType = unwrappedType._def.innerType;
+        }
+        const typeName = unwrappedType._def?.typeName;
+        const property = {};
+        // Add description if available (check both wrapped and unwrapped)
+        if (zodType._def?.description) {
+            property.description = zodType._def.description;
+        }
+        else if (unwrappedType._def?.description) {
+            property.description = unwrappedType._def.description;
+        }
+        switch (typeName) {
+            case "ZodString":
+                property.type = "string";
+                break;
+            case "ZodNumber":
+                property.type = "number";
+                break;
+            case "ZodBoolean":
+                property.type = "boolean";
+                break;
+            case "ZodArray":
+                property.type = "array";
+                // Handle array items
+                if (unwrappedType._def?.type) {
+                    property.items = this.convertZodTypeToJsonSchema(unwrappedType._def.type);
+                }
+                else {
+                    property.items = { type: "string" };
+                }
+                break;
+            case "ZodObject":
+                property.type = "object";
+                // Recursively handle object properties if needed
+                if (unwrappedType._def?.shape) {
+                    const nestedSchema = this.convertZodSchemaToJsonSchema(unwrappedType._def.shape);
+                    property.properties = nestedSchema.properties;
+                    if (nestedSchema.required?.length > 0) {
+                        property.required = nestedSchema.required;
+                    }
+                }
+                break;
+            case "ZodRecord":
+                property.type = "object";
+                break;
+            case "ZodEnum":
+                property.type = "string";
+                // Handle enum values
+                if (unwrappedType._def?.values) {
+                    property.enum = Array.from(unwrappedType._def.values);
+                }
+                break;
+            case "ZodUnion":
+                // For unions, try to extract types
+                if (unwrappedType._def?.options && unwrappedType._def.options.length > 0) {
+                    const firstOption = unwrappedType._def.options[0];
+                    const firstType = this.convertZodTypeToJsonSchema(firstOption);
+                    property.type = firstType.type;
+                    if (firstType.enum) {
+                        property.enum = firstType.enum;
+                    }
+                }
+                else {
+                    property.type = "string";
+                }
+                break;
+            default:
+                property.type = "string";
+        }
+        return property;
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+//# sourceMappingURL=tool-registry.js.map

package/dist/mcp/tools/activity.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Activity Tools - Clean Architecture Implementation
+ *
+ * Tools for managing Hailer activities:
+ * - List activities with filtering and pagination (READ)
+ * - Show activity details (READ)
+ * - Create new activities (WRITE)
+ * - Update existing activities (WRITE)
+ */
+import { Tool } from '../tool-registry';
+export declare const listActivitiesTool: Tool;
+export declare const showActivityByIdTool: Tool;
+export declare const createActivityTool: Tool;
+export declare const updateActivityTool: Tool;
+//# sourceMappingURL=activity.d.ts.map