@hailer/mcp 0.0.1

package/dist/mcp/signal-handler.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignalHandler = exports.SignalHandler = void 0;
+const zod_1 = require("zod");
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'signal-handler' });
+class SignalHandler {
+    client;
+    workspaceCache;
+    subscriptions = new Map();
+    signalHistory = [];
+    maxHistorySize = 100;
+    constructor(client, workspaceCache) {
+        this.client = client;
+        this.workspaceCache = workspaceCache;
+        this.initializeSignalHandling();
+    }
+    initializeSignalHandling() {
+        // Register for all signals from the socket client
+        this.client.socket.on('signals', (signal) => {
+            this.handleIncomingSignal(signal);
+        });
+    }
+    handleIncomingSignal(rawSignal) {
+        try {
+            const [eventType, eventData] = rawSignal;
+            const signal = {
+                type: eventType,
+                data: eventData,
+                timestamp: Date.now(),
+                workspaceId: this.workspaceCache?.currentWorkspace._id,
+            };
+            // Add to history
+            this.addToHistory(signal);
+            // Dispatch to subscriptions
+            this.dispatchSignal(signal);
+            // Handle built-in signal processing
+            this.processBuiltinSignals(signal);
+        }
+        catch (error) {
+            logger.error('Failed to handle incoming signal', error);
+        }
+    }
+    addToHistory(signal) {
+        this.signalHistory.unshift(signal);
+        if (this.signalHistory.length > this.maxHistorySize) {
+            this.signalHistory = this.signalHistory.slice(0, this.maxHistorySize);
+        }
+    }
+    dispatchSignal(signal) {
+        for (const subscription of this.subscriptions.values()) {
+            // Check if signal type matches subscription
+            if (!subscription.types.includes(signal.type)) {
+                continue;
+            }
+            // Check workspace filtering
+            if (subscription.workspaceId && signal.workspaceId !== subscription.workspaceId) {
+                continue;
+            }
+            try {
+                subscription.handler(signal);
+            }
+            catch (error) {
+                logger.error('Signal handler failed', error, { subscriptionId: subscription.id });
+            }
+        }
+    }
+    processBuiltinSignals(signal) {
+        switch (signal.type) {
+            case 'activities.updated':
+                this.handleActivityUpdated(signal);
+                break;
+            case 'activities.created':
+                this.handleActivityCreated(signal);
+                break;
+            case 'discussion.message':
+                this.handleDiscussionMessage(signal);
+                break;
+            case 'workspace.updated':
+                this.handleWorkspaceUpdated(signal);
+                break;
+            case 'messenger.new':
+                this.handleMessengerNew(signal);
+                break;
+            case 'cache.invalidate':
+                this.handleCacheInvalidate(signal);
+                break;
+            default:
+                logger.debug('Unhandled signal type received', { signalType: signal.type });
+        }
+    }
+    handleActivityUpdated(signal) {
+        logger.debug('Activity updated signal received', {
+            activityId: signal.data?._id || signal.data?.id,
+            workspaceId: signal.workspaceId
+        });
+        // TODO: Update workspace cache if we have the activity cached
+        // This could invalidate cached activity lists and trigger re-fetching
+        // Example: Emit MCP notification for real-time updates
+        // this.emitMcpNotification('activity_updated', signal.data);
+    }
+    handleActivityCreated(signal) {
+        logger.debug('Activity created signal received', {
+            activityId: signal.data?._id || signal.data?.id,
+            workspaceId: signal.workspaceId
+        });
+        // TODO: Add new activity to workspace cache
+        // This could update activity counts and lists
+    }
+    handleDiscussionMessage(signal) {
+        logger.debug('Discussion message signal received', {
+            discussionId: signal.data?.discussionId,
+            workspaceId: signal.workspaceId
+        });
+        // TODO: Update message cache if we're tracking discussions
+        // This could trigger notifications for AI agents monitoring conversations
+    }
+    handleWorkspaceUpdated(signal) {
+        logger.debug('Workspace updated signal received', {
+            workspaceId: signal.workspaceId
+        });
+        // TODO: Refresh workspace cache
+        // This could trigger re-fetching of workspace metadata
+    }
+    handleMessengerNew(signal) {
+        logger.debug('Messenger signal received', {
+            workspaceId: signal.workspaceId
+        });
+        // This is triggered when new messages arrive in discussions
+        // The MCP client should be handling this signal for processing user requests
+    }
+    async handleCacheInvalidate(signal) {
+        if (!this.workspaceCache) {
+            logger.debug('No workspace cache available, skipping cache invalidation');
+            return;
+        }
+        const meta = signal.data || {};
+        logger.debug('Cache invalidate signal received', {
+            workspaceId: signal.workspaceId,
+            meta
+        });
+        try {
+            // Refresh cache by fetching fresh data - pass meta to let backend decide what to return
+            const init = await this.client.socket.request('v2.core.init', [meta]);
+            // Update workspace cache with fresh data
+            if (init.processes) {
+                this.workspaceCache.rawInit.processes = init.processes;
+                logger.info('Workflows cache refreshed', {
+                    workflowCount: init.processes.length
+                });
+            }
+            if (init.users) {
+                this.workspaceCache.users = init.users;
+                logger.info('Users cache refreshed', {
+                    userCount: init.users.length
+                });
+            }
+            if (init.network) {
+                this.workspaceCache.currentWorkspace = init.network;
+                logger.info('Current workspace cache refreshed');
+            }
+            if (init.networks) {
+                this.workspaceCache.allWorkspaces = init.networks;
+                logger.info('All workspaces cache refreshed', {
+                    workspaceCount: Object.keys(init.networks).length
+                });
+            }
+        }
+        catch (error) {
+            logger.error('Failed to refresh cache after invalidation signal', error);
+        }
+    }
+    // Public API for subscription management
+    subscribe(id, types, handler, workspaceId) {
+        // Check if subscription already exists
+        if (this.subscriptions.has(id)) {
+            logger.info('Replacing existing signal subscription', { subscriptionId: id });
+        }
+        const subscription = {
+            id,
+            types,
+            handler,
+            workspaceId,
+        };
+        this.subscriptions.set(id, subscription);
+        logger.info('Created signal subscription', {
+            subscriptionId: id,
+            signalTypes: types,
+            workspaceId
+        });
+    }
+    unsubscribe(id) {
+        const removed = this.subscriptions.delete(id);
+        if (removed) {
+            logger.info('Removed signal subscription', { subscriptionId: id });
+        }
+        return removed;
+    }
+    getSignalHistory(types, limit, workspaceId) {
+        let filtered = this.signalHistory;
+        if (types && types.length > 0) {
+            filtered = filtered.filter(signal => types.includes(signal.type));
+        }
+        if (workspaceId) {
+            filtered = filtered.filter(signal => signal.workspaceId === workspaceId);
+        }
+        if (limit && limit > 0) {
+            filtered = filtered.slice(0, limit);
+        }
+        return filtered;
+    }
+    getActiveSubscriptions() {
+        return Array.from(this.subscriptions.values());
+    }
+    clearHistory() {
+        const previousCount = this.signalHistory.length;
+        this.signalHistory = [];
+        logger.info('Signal history cleared', { previousHistorySize: previousCount });
+    }
+    // Utility methods for MCP integration
+    createMcpSignalTools(server) {
+        // Add MCP tools for signal subscription management
+        server.tool("subscribe_to_signals", "🔔 Subscribe to real-time Hailer signals - Get notified of activity updates, new messages, and workspace changes", {
+            types: zod_1.z.array(zod_1.z.enum([
+                'activities.updated',
+                'activities.created',
+                'activities.deleted',
+                'discussion.message',
+                'user.joined',
+                'user.left',
+                'workspace.updated',
+                'process.updated',
+                'cache.invalidate'
+            ])).describe("Signal types to subscribe to"),
+            workspaceId: zod_1.z.string().optional().describe("Optional workspace ID to filter signals"),
+        }, async (args) => {
+            const subscriptionId = `mcp-${Date.now()}`;
+            this.subscribe(subscriptionId, args.types, (signal) => {
+                // TODO: Send MCP notification to client
+                logger.debug('MCP signal notification', {
+                    subscriptionId,
+                    signalType: signal.type,
+                    workspaceId: signal.workspaceId
+                });
+            }, args.workspaceId);
+            return {
+                content: [{
+                        type: "text",
+                        text: `🔔 Subscribed to real-time signals!\n\n` +
+                            `📡 Subscription ID: ${subscriptionId}\n` +
+                            `📋 Signal types: ${args.types.join(", ")}\n` +
+                            `${args.workspaceId ? `🏢 Workspace filter: ${args.workspaceId}\n` : ''}` +
+                            `\n💡 You'll now receive real-time notifications for these events.\n` +
+                            `Use get_signal_history to see recent signals.`,
+                    }],
+            };
+        });
+        server.tool("get_signal_history", "📜 Get recent real-time signal history - See what's been happening in your workspace", {
+            types: zod_1.z.array(zod_1.z.string()).optional().describe("Optional filter for specific signal types"),
+            limit: zod_1.z.number().optional().default(20).describe("Maximum number of signals to return"),
+            workspaceId: zod_1.z.string().optional().describe("Optional workspace ID to filter signals"),
+        }, async (args) => {
+            const history = this.getSignalHistory(args.types, args.limit, args.workspaceId);
+            const summary = {
+                totalSignals: history.length,
+                timeRange: history.length > 0 ? {
+                    newest: new Date(history[0].timestamp).toISOString(),
+                    oldest: new Date(history[history.length - 1].timestamp).toISOString(),
+                } : null,
+                typeBreakdown: history.reduce((acc, signal) => {
+                    acc[signal.type] = (acc[signal.type] || 0) + 1;
+                    return acc;
+                }, {}),
+                signals: history.map(signal => ({
+                    type: signal.type,
+                    timestamp: new Date(signal.timestamp).toISOString(),
+                    workspaceId: signal.workspaceId,
+                    data: signal.data,
+                })),
+            };
+            return {
+                content: [{
+                        type: "text",
+                        text: `📜 Signal History (${history.length} signals)\n\n` +
+                            `📊 Summary:\n` +
+                            `${Object.entries(summary.typeBreakdown).map(([type, count]) => `- ${type}: ${count}`).join('\n')}\n\n` +
+                            `⏰ Time range: ${summary.timeRange ? `${summary.timeRange.oldest} → ${summary.timeRange.newest}` : 'No signals'}\n\n` +
+                            `📡 Real-time signals help you stay updated on workspace activity!\n\n` +
+                            `${JSON.stringify(summary, null, 2)}`,
+                    }],
+            };
+        });
+        server.tool("list_signal_subscriptions", "📋 List active signal subscriptions - See what real-time notifications are configured", {}, async () => {
+            const subscriptions = this.getActiveSubscriptions();
+            return {
+                content: [{
+                        type: "text",
+                        text: `📋 Active Signal Subscriptions (${subscriptions.length})\n\n` +
+                            (subscriptions.length > 0
+                                ? subscriptions.map((sub, index) => `${index + 1}. **${sub.id}**\n` +
+                                    `   - Types: ${sub.types.join(", ")}\n` +
+                                    `   - Workspace: ${sub.workspaceId || "All workspaces"}`).join('\n\n')
+                                : "No active subscriptions") +
+                            `\n\n💡 Use subscribe_to_signals to create new subscriptions.\n` +
+                            `💡 Subscriptions automatically receive real-time updates.`,
+                    }],
+            };
+        });
+    }
+}
+exports.SignalHandler = SignalHandler;
+// Factory function for creating signal handler
+const createSignalHandler = (clients, workspaceCache) => {
+    return new SignalHandler(clients, workspaceCache);
+};
+exports.createSignalHandler = createSignalHandler;
+//# sourceMappingURL=signal-handler.js.map

package/dist/mcp/tool-registry.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Clean Tool Registry with Dependency Injection
+ *
+ * No singletons, no statics - just clean, explicit tool registration
+ * with per-agent access control via dependency injection.
+ */
+import { z } from 'zod';
+import { UserContext } from './UserContextCache';
+/**
+ * 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)
+ */
+export declare enum ToolGroup {
+    READ = "read",
+    WRITE = "write",
+    PLAYGROUND = "playground",
+    NUCLEAR = "nuclear"
+}
+/**
+ * Tool definition interface
+ */
+export interface Tool<TSchema extends z.ZodType = z.ZodType> {
+    name: string;
+    group: ToolGroup;
+    description: string;
+    schema: TSchema;
+    execute: (args: z.infer<TSchema>, context: UserContext) => Promise<any>;
+}
+/**
+ * Tool definition for MCP protocol (JSON-RPC)
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: any;
+}
+/**
+ * ToolRegistry - Clean, testable, dependency-injected tool registry
+ *
+ * NO SINGLETON PATTERN - instantiated explicitly and passed through DI
+ */
+export declare class ToolRegistry {
+    private tools;
+    private enableNuclearTools;
+    constructor(options?: {
+        enableNuclearTools?: boolean;
+    });
+    /**
+     * Add a tool to the registry
+     */
+    addTool(tool: Tool): void;
+    /**
+     * 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?: {
+        allowedGroups?: ToolGroup[];
+        allowedTools?: string[];
+    }): ToolDefinition[];
+    /**
+     * Get specific tool schema on-demand
+     * Token-efficient: ~200 tokens per tool vs loading all tools upfront
+     */
+    getToolSchema(toolName: string): ToolDefinition | null;
+    /**
+     * Execute tool with validation
+     */
+    executeTool(name: string, args: any, context: UserContext): Promise<any>;
+    /**
+     * Get tool metadata (for access control checks)
+     */
+    getTool(name: string): Tool | undefined;
+    /**
+     * Get total tool count
+     */
+    getToolCount(): number;
+    /**
+     * Get statistics for monitoring/debugging
+     */
+    getCacheStats(): {
+        totalTools: number;
+        toolNames: string[];
+        byGroup: Record<ToolGroup, number>;
+    };
+    /**
+     * Convert Zod schema to JSON Schema format (required by MCP protocol)
+     */
+    private convertZodSchemaToJsonSchema;
+    /**
+     * Convert a single Zod type to JSON Schema
+     */
+    private convertZodTypeToJsonSchema;
+}
+//# sourceMappingURL=tool-registry.d.ts.map