@hailer/mcp 0.1.11 → 0.1.13

package/dist/core.js

@@ -11,6 +11,9 @@ const config_1 = require("./config");
 const factory_1 = require("./client/factory");
 const mcp_server_1 = require("./mcp-server");
 const tool_registry_1 = require("./mcp/tool-registry");
+const bug_reports_1 = require("./modules/bug-reports");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const bot_config_1 = require("./mcp/tools/bot-config");
 class Core {
     logger;
     appConfig;
@@ -18,6 +21,7 @@ class Core {
     mcpServer;
     daemonManager = null;
     statusLogInterval;
+    bugReportsModule;
     constructor() {
         // Initialize logger first
         this.logger = (0, logger_1.createLogger)({
@@ -58,10 +62,14 @@ class Core {
                     await this.startMCPServer();
                 }
             }
+            // Initialize bot config persistence (reads config from Hailer Agent Directory)
+            await this.initBotConfig();
             // Start client/daemon AFTER MCP server is ready
             if (this.appConfig.server.enableClient) {
                 await this.startMCPClient();
             }
+            // Start Bug Monitor service (reads config from Hailer)
+            await this.startBugMonitor();
             this.setupGracefulShutdown();
             this.logger.info('All configured services started successfully');
         }
@@ -94,6 +102,66 @@ class Core {
             });
         }
     }
+    async startBugMonitor() {
+        try {
+            // Get first configured account for Bug Reports Module
+            const accounts = Object.entries(this.appConfig.hailerAccounts);
+            if (accounts.length === 0) {
+                this.logger.info('No Hailer accounts configured - Bug Reports Module disabled');
+                return;
+            }
+            const [apiKey] = accounts[0];
+            const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+            this.bugReportsModule = new bug_reports_1.BugReportsModule(userContext);
+            // Register bot user IDs to ignore (so bug monitor only processes human messages)
+            if (this.daemonManager) {
+                const daemonStatus = this.daemonManager.getStatus();
+                for (const daemon of daemonStatus) {
+                    this.bugReportsModule.registerBotUser(daemon.botId);
+                    this.logger.debug('Registered bot user for bug monitor to ignore', { botId: daemon.botId });
+                }
+            }
+            // Register giuseppe disabled handler to trigger HAL response (BEFORE start!)
+            this.bugReportsModule.onGiuseppeDisabled(async (bug) => {
+                if (this.daemonManager && bug.discussionId) {
+                    const context = `[System notification: A new bug report "${bug.name}" was detected, but Giuseppe (the auto-fix bot) is currently disabled. The user may ask how to enable Giuseppe or want to know more about this bug. Be helpful and explain they can enable Giuseppe in the AI Hub app.]`;
+                    await this.daemonManager.triggerHalResponse(bug.discussionId, bug.id, context);
+                }
+            });
+            await this.bugReportsModule.start();
+            if (this.bugReportsModule.isRunning()) {
+                const config = this.bugReportsModule.getConfig();
+                this.logger.info('Bug Reports Module started', {
+                    autoFix: config.autoFix,
+                    interval: `${config.intervalMs / 1000}s`
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn('Bug Reports Module failed to start - server will continue without bug monitoring', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    async initBotConfig() {
+        try {
+            // Get first configured account for bot config persistence
+            const accounts = Object.entries(this.appConfig.hailerAccounts);
+            if (accounts.length === 0) {
+                this.logger.info('No Hailer accounts configured - Bot config persistence disabled');
+                return;
+            }
+            const [apiKey] = accounts[0];
+            const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+            await (0, bot_config_1.initBotConfigPersistence)(userContext.hailer);
+            this.logger.info('Bot config persistence initialized');
+        }
+        catch (error) {
+            this.logger.warn('Bot config persistence failed to initialize - using in-memory defaults', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
     async initializeDaemonMode() {
         this.logger.info('Initializing Chat Agent Daemon');
         // Check for orchestrator mode via environment variable
@@ -126,6 +194,10 @@ class Core {
             if (this.statusLogInterval) {
                 clearInterval(this.statusLogInterval);
             }
+            // Stop Bug Reports Module
+            if (this.bugReportsModule) {
+                await this.bugReportsModule.stop();
+            }
             if (this.daemonManager) {
                 this.daemonManager.stopAll();
                 this.logger.info('Chat Agent Daemon stopped');

package/dist/mcp/hailer-clients.d.ts

@@ -42,4 +42,8 @@ export declare const createHailerClientByApiKey: (apiKey: string) => Promise<Hai
  * Disconnect client by API key (new unified approach)
  */
 export declare const disconnectHailerClientByApiKey: (apiKey: string) => void;
+/**
+ * Subscribe to signals for a client connection
+ */
+export declare const subscribeToSignal: (apiKey: string, eventType: SignalType | string, handler: SignalHandler) => (() => void) | null;
 //# sourceMappingURL=hailer-clients.d.ts.map

package/dist/mcp/hailer-clients.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disconnectHailerClientByApiKey = exports.createHailerClientByApiKey = exports.HailerClientManager = void 0;
+exports.subscribeToSignal = exports.disconnectHailerClientByApiKey = exports.createHailerClientByApiKey = exports.HailerClientManager = void 0;
 exports.getCurrentUserId = getCurrentUserId;
 const cli_1 = require("@hailer/cli");
 const auth_1 = require("./auth");
@@ -243,4 +243,19 @@ const disconnectHailerClientByApiKey = (apiKey) => {
     }
 };
 exports.disconnectHailerClientByApiKey = disconnectHailerClientByApiKey;
+/**
+ * Subscribe to signals for a client connection
+ */
+const subscribeToSignal = (apiKey, eventType, handler) => {
+    const clientManager = connectionPool.get(apiKey);
+    if (!clientManager) {
+        return null;
+    }
+    clientManager.onSignal(eventType, handler);
+    // Return unsubscribe function
+    return () => {
+        clientManager.offSignal(eventType, handler);
+    };
+};
+exports.subscribeToSignal = subscribeToSignal;
 //# sourceMappingURL=hailer-clients.js.map

package/dist/mcp/tools/app-scaffold.js

@@ -47,6 +47,79 @@ const logger_1 = require("../../lib/logger");
 const config_1 = require("../../config");
 const tool_helpers_1 = require("../utils/tool-helpers");
 const logger = (0, logger_1.createLogger)({ component: 'app-scaffold' });
+// Color palette for app icons (gradient pairs)
+const APP_ICON_COLORS = [
+    { color1: '#3b82f6', color2: '#1d4ed8' }, // Blue
+    { color1: '#8b5cf6', color2: '#6d28d9' }, // Purple
+    { color1: '#22c55e', color2: '#15803d' }, // Green
+    { color1: '#f59e0b', color2: '#d97706' }, // Amber
+    { color1: '#ef4444', color2: '#b91c1c' }, // Red
+    { color1: '#14b8a6', color2: '#0d9488' }, // Teal
+    { color1: '#ec4899', color2: '#be185d' }, // Pink
+    { color1: '#6366f1', color2: '#4338ca' }, // Indigo
+];
+/**
+ * Get initials from project name (e.g., "lineup-manager" -> "LM")
+ */
+function getInitials(name) {
+    // Split by common separators
+    const words = name.split(/[-_\s]+/).filter(w => w.length > 0);
+    if (words.length >= 2) {
+        // Take first letter of first two words
+        return (words[0][0] + words[1][0]).toUpperCase();
+    }
+    else if (words.length === 1) {
+        // Take first two letters or first letter doubled
+        const word = words[0];
+        return word.length >= 2
+            ? (word[0] + word[1]).toUpperCase()
+            : (word[0] + word[0]).toUpperCase();
+    }
+    return 'AP'; // Default
+}
+/**
+ * Get consistent color based on name hash
+ */
+function getColorFromName(name) {
+    let hash = 0;
+    for (let i = 0; i < name.length; i++) {
+        hash = ((hash << 5) - hash) + name.charCodeAt(i);
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    const index = Math.abs(hash) % APP_ICON_COLORS.length;
+    return APP_ICON_COLORS[index];
+}
+/**
+ * Generate styled app icon as JPEG buffer
+ */
+async function generateAppIcon(name) {
+    const sharp = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+    const initials = getInitials(name);
+    const colors = getColorFromName(name);
+    const svg = `<svg width="256" height="256" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+      <linearGradient id="bgGrad" x1="0%" y1="0%" x2="100%" y2="100%">
+        <stop offset="0%" style="stop-color:${colors.color1}"/>
+        <stop offset="100%" style="stop-color:${colors.color2}"/>
+      </linearGradient>
+      <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
+        <feDropShadow dx="2" dy="4" stdDeviation="3" flood-opacity="0.3"/>
+      </filter>
+    </defs>
+    <rect width="256" height="256" rx="50" fill="url(#bgGrad)"/>
+    <rect x="8" y="8" width="240" height="240" rx="42" fill="none" stroke="rgba(255,255,255,0.2)" stroke-width="2"/>
+    <text x="128" y="168" text-anchor="middle"
+          font-family="Arial Black, Arial, sans-serif"
+          font-size="${initials.length > 2 ? 80 : 110}"
+          font-weight="900"
+          fill="white"
+          filter="url(#shadow)">${initials}</text>
+  </svg>`;
+    return sharp(Buffer.from(svg))
+        .flatten({ background: colors.color1 })
+        .jpeg({ quality: 95 })
+        .toBuffer();
+}
 const scaffoldHailerAppDescription = `Scaffold new Hailer app from template`;
 exports.scaffoldHailerAppTool = {
     name: 'scaffold_hailer_app',
@@ -93,7 +166,25 @@ exports.scaffoldHailerAppTool = {
                     encoding: 'utf-8',
                     shell: '/bin/bash'
                 });
-                responseText += `✅ Project scaffolded\n\n`;
+                responseText += `✅ Project scaffolded\n`;
+                // Immediately update manifest.json with correct author (before Hailer reads it)
+                try {
+                    const manifestPath = path.join(projectPath, 'public', 'manifest.json');
+                    if (fs.existsSync(manifestPath)) {
+                        const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+                        const manifest = JSON.parse(manifestContent);
+                        manifest.author = 'Hailer Oy';
+                        if (context.email) {
+                            manifest.contributors = [context.email];
+                        }
+                        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+                        responseText += `   ✅ Set author: Hailer Oy\n`;
+                    }
+                }
+                catch {
+                    // Non-fatal, continue
+                }
+                responseText += `\n`;
             }
             catch (error) {
                 const errorMessage = (0, tool_helpers_1.extractErrorMessage)(error);
@@ -158,7 +249,7 @@ exports.scaffoldHailerAppTool = {
             }
             let appId;
             let workspaceId;
-            // Step 4: Create dev app in Hailer
+            // Step 4: Create dev app in Hailer (with auto-generated icon)
             if (args.autoCreateDevApp !== false) {
                 responseText += `⏳ Step 4/8: Creating dev app entry in Hailer...\n`;
                 try {
@@ -167,6 +258,34 @@ exports.scaffoldHailerAppTool = {
                         responseText += `⚠️ Workspace cache not available, skipping app creation\n\n`;
                     }
                     else {
+                        // Generate and upload app icon
+                        let imageId;
+                        try {
+                            responseText += `   📸 Generating app icon...\n`;
+                            const iconBuffer = await generateAppIcon(args.projectName);
+                            // Save to temp file and upload
+                            const os = await Promise.resolve().then(() => __importStar(require('os')));
+                            const tempPath = path.join(os.tmpdir(), `app-icon-${Date.now()}.jpg`);
+                            fs.writeFileSync(tempPath, iconBuffer);
+                            const uploadResult = await context.hailer.uploadFile({
+                                path: tempPath,
+                                filename: 'app-icon.jpg',
+                                isPublic: true
+                            });
+                            // Clean up temp file
+                            try {
+                                fs.unlinkSync(tempPath);
+                            }
+                            catch { /* ignore */ }
+                            if (uploadResult.success && uploadResult.fileId) {
+                                imageId = uploadResult.fileId;
+                                responseText += `   ✅ Icon uploaded: ${imageId}\n`;
+                            }
+                        }
+                        catch (iconError) {
+                            logger.warn('Failed to generate/upload app icon', { error: iconError });
+                            responseText += `   ⚠️ Icon generation skipped\n`;
+                        }
                         const appData = {
                             cid: workspaceId,
                             name: args.projectName,
@@ -175,6 +294,9 @@ exports.scaffoldHailerAppTool = {
                         if (args.description) {
                             appData.description = args.description;
                         }
+                        if (imageId) {
+                            appData.image = imageId;
+                        }
                         const result = await context.hailer.request('v3.app.create', [appData]);
                         appId = result.appId || result._id;
                         responseText += `✅ App created: ${appId}\n`;
@@ -209,7 +331,7 @@ exports.scaffoldHailerAppTool = {
             }
             // Step 6: Update manifest.json with app ID
             if (appId) {
-                responseText += `⏳ Step 6/8: Updating manifest.json with app ID...\n`;
+                responseText += `⏳ Step 6/8: Adding appId to manifest.json...\n`;
                 try {
                     const manifestPath = path.join(projectPath, 'public', 'manifest.json');
                     if (fs.existsSync(manifestPath)) {
@@ -217,10 +339,10 @@ exports.scaffoldHailerAppTool = {
                         const manifest = JSON.parse(manifestContent);
                         manifest.appId = appId;
                         fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-                        responseText += `✅ manifest.json updated with appId\n\n`;
+                        responseText += `   ✅ appId: ${appId}\n\n`;
                     }
                     else {
-                        responseText += `⚠️ manifest.json not found at ${manifestPath}\n\n`;
+                        responseText += `⚠️ manifest.json not found\n\n`;
                     }
                 }
                 catch (error) {

package/dist/mcp/tools/bot-config.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Bot Configuration MCP Tools
+ *
+ * Manages which bots are enabled/disabled in the workspace.
+ * Config is stored in the Agent Directory workflow - agents are activities.
+ * - Deployed agents phase = enabled
+ * - Retired agents phase = disabled
+ *
+ * Architecture:
+ * - In-memory state is primary (for speed)
+ * - Agent Directory workflow is persistence layer (agents as activities, phases for state)
+ * - On startup: Load config from Hailer by checking which phase each agent is in
+ * - On change: Move agent activity between phases
+ */
+import { z } from 'zod';
+import { Tool } from '../tool-registry';
+import { HailerApiClient } from '../utils/index';
+/**
+ * Available bots - single source of truth
+ *
+ * All bots that can be enabled/disabled in the workspace.
+ * This list should match the AI Hub app and agent definitions.
+ */
+export declare const AVAILABLE_BOTS: {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+}[];
+export declare function onBotStateChange(callback: (botId: string, enabled: boolean) => void): void;
+export declare function getBotState(): Record<string, boolean>;
+/**
+ * Set bot enabled state
+ *
+ * Updates in-memory state and persists to Agent Directory by moving
+ * the agent activity to the appropriate phase (deployed/retired).
+ */
+export declare function setBotEnabled(botId: string, enabled: boolean): void;
+/**
+ * Initialize persistence layer
+ * Called once during MCP server startup
+ *
+ * Loads agent enabled state from the Agent Directory workflow:
+ * - Agents in DEPLOYED_PHASE_ID are enabled
+ * - Agents in RETIRED_PHASE_ID are disabled
+ *
+ * @param client - HailerApiClient instance for API calls
+ */
+export declare function initBotConfigPersistence(client: HailerApiClient): Promise<void>;
+/**
+ * Check if persistence is initialized
+ */
+export declare function isPersistenceInitialized(): boolean;
+/**
+ * Get persistence status info (for debugging)
+ */
+export declare function getPersistenceStatus(): {
+    initialized: boolean;
+    workflowId: string;
+    deployedPhaseId: string;
+    retiredPhaseId: string;
+    agentActivityIds: Record<string, string>;
+    hasClient: boolean;
+};
+/**
+ * List available bots and their status
+ */
+export declare const listBotsConfigTool: Tool;
+/**
+ * Enable a bot
+ */
+export declare const enableBotTool: Tool;
+/**
+ * Disable a bot
+ */
+export declare const disableBotTool: Tool;
+export declare const botConfigTools: Tool<z.ZodType<any, z.ZodTypeDef, any>>[];
+//# sourceMappingURL=bot-config.d.ts.map