@hailer/mcp 0.1.11 → 0.1.12

package/dist/services/bug-monitor.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Bug Monitor Service
+ *
+ * Periodically checks for new bug reports and can trigger auto-fix workflows.
+ * Configuration is read from Hailer's MCP Config workflow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BugMonitorService = void 0;
+exports.getBugMonitor = getBugMonitor;
+const logger_1 = require("../lib/logger");
+const UserContextCache_1 = require("../mcp/UserContextCache");
+const config_1 = require("../config");
+const logger = (0, logger_1.createLogger)({ component: 'bug-monitor' });
+class BugMonitorService {
+    interval;
+    config;
+    userContext;
+    bugWorkflowId;
+    newPhaseId;
+    fixedPhaseId;
+    processedBugIds = new Set();
+    async start() {
+        logger.info('Starting Bug Monitor Service...');
+        try {
+            // Get API key from first configured account
+            const appConfig = (0, config_1.createApplicationConfig)();
+            const accounts = Object.entries(appConfig.hailerAccounts);
+            if (accounts.length === 0) {
+                logger.warn('No Hailer accounts configured, Bug Monitor disabled');
+                return;
+            }
+            const [apiKey] = accounts[0];
+            this.userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+            // Load config from Hailer
+            await this.loadConfig();
+            if (!this.config?.enabled) {
+                logger.info('Bug Monitor is disabled in config');
+                return;
+            }
+            // Find Bug Reports workflow
+            await this.findBugWorkflow();
+            if (!this.bugWorkflowId) {
+                logger.warn(`Bug Reports workflow "${this.config.workflowName}" not found`);
+                return;
+            }
+            // Start polling
+            logger.info('Bug Monitor started', {
+                workflowName: this.config.workflowName,
+                intervalMs: this.config.intervalMs,
+                autoFix: this.config.autoFix
+            });
+            // Initial check
+            await this.checkForNewBugs();
+            // Start interval
+            this.interval = setInterval(async () => {
+                await this.checkForNewBugs();
+            }, this.config.intervalMs);
+        }
+        catch (error) {
+            logger.error('Failed to start Bug Monitor', { error });
+        }
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+            logger.info('Bug Monitor stopped');
+        }
+    }
+    async loadConfig() {
+        if (!this.userContext)
+            return;
+        try {
+            const { workspaceCache, hailer } = this.userContext;
+            // Find MCP Config workflow from cached init data
+            const workflows = Object.values(workspaceCache.rawInit.processes || {});
+            const mcpConfigWorkflow = workflows.find((w) => w.name?.includes('MCP config'));
+            if (!mcpConfigWorkflow) {
+                logger.warn('MCP Config workflow not found, using defaults');
+                this.config = {
+                    enabled: true,
+                    workflowName: 'Bug Reports',
+                    intervalMs: 300000, // 5 minutes
+                    autoFix: false,
+                    notifyOnNew: true
+                };
+                return;
+            }
+            // Get phases
+            const phases = Object.values(mcpConfigWorkflow.phases || {});
+            if (!phases || phases.length === 0) {
+                logger.warn('No phases in MCP Config workflow');
+                this.config = {
+                    enabled: true,
+                    workflowName: 'Bug Reports',
+                    intervalMs: 300000,
+                    autoFix: false,
+                    notifyOnNew: true
+                };
+                return;
+            }
+            const firstPhase = phases[0];
+            // Find Bug Monitor Service activity
+            const result = await hailer.fetchActivityList(mcpConfigWorkflow._id, firstPhase._id, 100);
+            const activities = result?.activities || result || [];
+            const bugMonitorActivity = activities.find((a) => a.name === 'Bug Monitor Service');
+            if (!bugMonitorActivity) {
+                logger.info('Bug Monitor Service config not found, using defaults');
+                this.config = {
+                    enabled: true,
+                    workflowName: 'Bug Reports',
+                    intervalMs: 300000,
+                    autoFix: false,
+                    notifyOnNew: true
+                };
+                return;
+            }
+            // Get full activity to read customContext field
+            const fullActivity = await hailer.fetchActivityById(bugMonitorActivity._id);
+            // Find customContext field value (it's a textarea field)
+            const fields = fullActivity.fields || {};
+            let customContextValue;
+            for (const fieldData of Object.values(fields)) {
+                if (fieldData.type === 'textarea' && fieldData.value) {
+                    try {
+                        // Try to parse as JSON - this might be our config
+                        JSON.parse(fieldData.value);
+                        customContextValue = fieldData.value;
+                        break;
+                    }
+                    catch {
+                        // Not JSON, skip
+                    }
+                }
+            }
+            if (customContextValue) {
+                this.config = JSON.parse(customContextValue);
+                logger.info('Loaded Bug Monitor config from Hailer', this.config);
+            }
+            else {
+                this.config = {
+                    enabled: true,
+                    workflowName: 'Bug Reports',
+                    intervalMs: 300000,
+                    autoFix: false,
+                    notifyOnNew: true
+                };
+            }
+        }
+        catch (error) {
+            logger.error('Failed to load Bug Monitor config', { error });
+            this.config = {
+                enabled: false,
+                workflowName: 'Bug Reports',
+                intervalMs: 300000,
+                autoFix: false,
+                notifyOnNew: true
+            };
+        }
+    }
+    async findBugWorkflow() {
+        if (!this.userContext || !this.config)
+            return;
+        try {
+            const { workspaceCache } = this.userContext;
+            // Find workflow from cached init data
+            const workflows = Object.values(workspaceCache.rawInit.processes || {});
+            const bugWorkflow = workflows.find((w) => w.name === this.config.workflowName);
+            if (bugWorkflow) {
+                this.bugWorkflowId = bugWorkflow._id;
+                // Get phases from workflow data
+                const phases = Object.values(bugWorkflow.phases || {});
+                this.newPhaseId = phases.find((p) => p.name === 'New')?._id;
+                this.fixedPhaseId = phases.find((p) => p.name === 'Fixed')?._id;
+                logger.info('Found Bug Reports workflow', {
+                    workflowId: this.bugWorkflowId,
+                    newPhaseId: this.newPhaseId,
+                    fixedPhaseId: this.fixedPhaseId
+                });
+            }
+        }
+        catch (error) {
+            logger.error('Failed to find Bug workflow', { error });
+        }
+    }
+    async checkForNewBugs() {
+        if (!this.userContext || !this.bugWorkflowId || !this.newPhaseId)
+            return;
+        try {
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchActivityList(this.bugWorkflowId, this.newPhaseId, 50);
+            const activities = result?.activities || result || [];
+            const newBugs = activities.filter((a) => !this.processedBugIds.has(a._id));
+            if (newBugs.length > 0) {
+                logger.info(`Found ${newBugs.length} new bug report(s)`, {
+                    bugs: newBugs.map((b) => ({ id: b._id, name: b.name }))
+                });
+                for (const bug of newBugs) {
+                    await this.processBug(bug);
+                    this.processedBugIds.add(bug._id);
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to check for bugs', { error });
+        }
+    }
+    async processBug(bug) {
+        logger.info('Processing bug report', {
+            id: bug._id,
+            name: bug.name
+        });
+        // Get full bug details
+        const fullBug = await this.userContext.hailer.fetchActivityById(bug._id);
+        // Extract field values
+        const fields = fullBug.fields || {};
+        let appId = '';
+        let appName = '';
+        let description = '';
+        let reportedBy = '';
+        for (const fieldData of Object.values(fields)) {
+            const value = fieldData.value;
+            if (typeof value === 'string') {
+                // Try to identify fields by content pattern
+                if (value.length === 24 && /^[a-f0-9]+$/.test(value)) {
+                    appId = value; // Likely app ID
+                }
+                else if (value.length < 50 && !description) {
+                    // Short text, could be appName or reportedBy
+                    if (!appName)
+                        appName = value;
+                    else if (!reportedBy)
+                        reportedBy = value;
+                }
+                else {
+                    description = value; // Longer text is likely description
+                }
+            }
+        }
+        const bugReport = {
+            id: bug._id,
+            name: bug.name,
+            appId,
+            appName,
+            reportedBy,
+            description,
+            createdAt: bug.createdHumanReadable || new Date().toISOString()
+        };
+        logger.info('Bug report details', bugReport);
+        if (this.config?.notifyOnNew && fullBug.discussion) {
+            // Post to discussion
+            try {
+                await this.userContext.hailer.sendDiscussionMessage(fullBug.discussion, `🤖 Bug Monitor: New bug detected!\n\nApp: ${appName} (${appId})\nReported by: ${reportedBy}\nDescription: ${description}\n\nAnalyzing...`);
+            }
+            catch (error) {
+                logger.warn('Failed to post to discussion', { error });
+            }
+        }
+        if (this.config?.autoFix) {
+            // TODO: Spawn agent to analyze and fix
+            logger.info('Auto-fix enabled but not yet implemented', { bugId: bug._id });
+        }
+    }
+}
+exports.BugMonitorService = BugMonitorService;
+// Singleton instance
+let bugMonitorInstance = null;
+function getBugMonitor() {
+    if (!bugMonitorInstance) {
+        bugMonitorInstance = new BugMonitorService();
+    }
+    return bugMonitorInstance;
+}
+//# sourceMappingURL=bug-monitor.js.map