@magic-ingredients/tiny-brain-local 0.3.10

package/dist/services/plan-watcher.service.js

@@ -0,0 +1,914 @@
+/**
+ * Plan Watcher Service
+ *
+ * Provides a web dashboard for monitoring and viewing plans in real-time.
+ * Implements singleton pattern to ensure only one watcher runs at a time.
+ */
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+import { fileURLToPath } from 'url';
+import open from 'better-opn';
+import { PlanningService } from '@magic-ingredients/tiny-brain-core';
+/**
+ * Singleton instance tracking
+ */
+let runningInstance = null;
+/**
+ * Plan Watcher Service
+ */
+export class PlanWatcherService {
+    server = null;
+    watcher = null;
+    watchInterval = null;
+    port = 0;
+    plans = new Map();
+    eventEmitter = new EventEmitter();
+    activePlanId = null;
+    showAll = false;
+    currentViewType = undefined;
+    context;
+    logger;
+    activeConnections = new Set();
+    boundOnPersonaChanged = null;
+    currentPersona = 'default';
+    constructor(context) {
+        this.context = context;
+        this.logger = context.logger;
+        this.logger.debug('PlanWatcher constructor called');
+        this.logger.debug(`context.getCurrentActivePersona exists? ${!!context.getCurrentActivePersona}`);
+        this.logger.debug(`context.activePersona: ${JSON.stringify(context.activePersona)}`);
+        // Get current persona from context if available
+        // First try the callback, then activePersona, then default
+        if (context.getCurrentActivePersona) {
+            const callbackResult = context.getCurrentActivePersona();
+            this.logger.debug(`getCurrentActivePersona() returned: ${callbackResult}`);
+            this.currentPersona = callbackResult || 'default';
+        }
+        else if (context.activePersona?.id) {
+            this.logger.debug(`Using activePersona.id: ${context.activePersona.id}`);
+            this.currentPersona = context.activePersona.id;
+        }
+        else {
+            this.logger.debug('Falling back to default persona');
+            this.currentPersona = 'default';
+        }
+        this.logger.info(`PlanWatcherService initialized with persona: ${this.currentPersona}`);
+    }
+    /**
+     * Start the plan watcher dashboard
+     */
+    async start(options = {}) {
+        try {
+            // Check if already running
+            if (this.isRunning()) {
+                return {
+                    success: false,
+                    error: new Error('Plan watcher is already running on port ' + this.port)
+                };
+            }
+            // Check singleton
+            if (runningInstance && runningInstance !== this) {
+                return {
+                    success: false,
+                    error: new Error('Another plan watcher instance is already running')
+                };
+            }
+            // Update current persona before starting
+            this.logger.debug('Getting current persona before start...');
+            const previousPersona = this.currentPersona;
+            this.currentPersona = this.getCurrentPersonaId();
+            this.logger.debug(`Persona changed from ${previousPersona} to ${this.currentPersona}`);
+            this.logger.info(`Starting plan watcher with persona: ${this.currentPersona}`);
+            // Register our callback to be notified of persona changes
+            if (this.context.personaChangeListeners) {
+                // Store the bound function so we can unregister it later
+                this.boundOnPersonaChanged = this.onPersonaChanged.bind(this);
+                const lengthBefore = this.context.personaChangeListeners.length;
+                this.context.personaChangeListeners.push(this.boundOnPersonaChanged);
+                const lengthAfter = this.context.personaChangeListeners.length;
+                this.logger.info(`Watcher registered callback. Listeners before: ${lengthBefore}, after: ${lengthAfter}`);
+                console.log(`🔍 Watcher registered callback. Array went from ${lengthBefore} to ${lengthAfter} listeners`);
+            }
+            else {
+                this.logger.warn('No personaChangeListeners array in context - callbacks not supported');
+                console.log('⚠️ No personaChangeListeners array in context');
+            }
+            // Set options
+            this.port = options.port || 8765;
+            this.showAll = options.showAll || false;
+            const autoOpen = options.autoOpen !== undefined
+                ? options.autoOpen
+                : true; // Default to true
+            // Load initial plans
+            const plansLoaded = await this.loadPlans();
+            // Create HTTP server
+            this.server = this.createHttpServer();
+            // Start server
+            await new Promise((resolve, reject) => {
+                const serverInstance = this.server;
+                if (!serverInstance)
+                    throw new Error('Server not created');
+                serverInstance.on('error', (err) => {
+                    if (err.code === 'EADDRINUSE') {
+                        reject(new Error(`Port ${this.port} is already in use`));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                serverInstance.listen(this.port, () => {
+                    this.logger.info(`Plan watcher started on port ${this.port}`);
+                    resolve();
+                });
+            });
+            // Set singleton instance
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            runningInstance = this;
+            // Start watching for changes
+            await this.startWatching();
+            const url = `http://localhost:${this.port}`;
+            // Open browser if autoOpen is enabled
+            if (autoOpen) {
+                try {
+                    await open(url);
+                    this.logger.info(`Opened browser at ${url}`);
+                }
+                catch (error) {
+                    this.logger.warn('Failed to open browser automatically:', error);
+                    // Don't fail the whole operation if browser opening fails
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    url,
+                    port: this.port,
+                    autoOpen,
+                    plansLoaded
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new Error(`Failed to start plan watcher: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            };
+        }
+    }
+    /**
+     * Stop the plan watcher dashboard
+     */
+    async stop() {
+        try {
+            if (!this.isRunning()) {
+                return {
+                    success: false,
+                    error: new Error('Plan watcher is not running')
+                };
+            }
+            // Unregister our callback
+            if (this.context.personaChangeListeners && this.boundOnPersonaChanged) {
+                const index = this.context.personaChangeListeners.indexOf(this.boundOnPersonaChanged);
+                if (index > -1) {
+                    this.context.personaChangeListeners.splice(index, 1);
+                }
+                this.boundOnPersonaChanged = null;
+            }
+            // Stop file watcher
+            if (this.watcher) {
+                this.watcher.close();
+                this.watcher = null;
+            }
+            // Stop polling interval
+            if (this.watchInterval) {
+                clearInterval(this.watchInterval);
+                this.watchInterval = null;
+            }
+            // Close all active SSE connections first
+            // This is important to prevent hanging on server.close()
+            for (const connection of this.activeConnections) {
+                try {
+                    connection.end();
+                }
+                catch {
+                    // Connection might already be closed
+                }
+            }
+            this.activeConnections.clear();
+            // Stop HTTP server
+            if (this.server) {
+                const serverToClose = this.server;
+                this.server = null; // Clear reference immediately
+                // Use a timeout to prevent indefinite hanging
+                await Promise.race([
+                    new Promise((resolve) => {
+                        serverToClose.close(() => {
+                            this.logger.info('Plan watcher stopped');
+                            resolve();
+                        });
+                    }),
+                    new Promise((resolve) => {
+                        setTimeout(() => {
+                            this.logger.warn('Force closing server after timeout');
+                            resolve();
+                        }, 1000); // 1 second timeout
+                    })
+                ]);
+            }
+            // Clear singleton if it's this instance
+            if (runningInstance === this) {
+                runningInstance = null;
+            }
+            // Clear data
+            this.plans.clear();
+            this.port = 0;
+            return { success: true, data: undefined };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new Error(`Failed to stop plan watcher: ${error instanceof Error ? error.message : 'Unknown error'}`)
+            };
+        }
+    }
+    /**
+     * Check if the watcher is running
+     */
+    isRunning() {
+        return this.server !== null && this.port > 0;
+    }
+    /**
+     * Get the URL of the running watcher
+     */
+    getUrl() {
+        if (!this.isRunning()) {
+            return {
+                success: false,
+                error: new Error('Plan watcher is not running')
+            };
+        }
+        return {
+            success: true,
+            data: `http://localhost:${this.port}`
+        };
+    }
+    /**
+     * Get the current active persona ID
+     * Uses the callback to always get the latest persona from MCP server
+     */
+    getCurrentPersonaId() {
+        this.logger.debug('getCurrentPersonaId called');
+        // Use callback if available, otherwise fallback to context snapshot
+        if (this.context.getCurrentActivePersona) {
+            const personaId = this.context.getCurrentActivePersona();
+            this.logger.debug(`Callback returned: ${personaId}`);
+            if (personaId) {
+                return personaId;
+            }
+        }
+        else {
+            this.logger.debug('No getCurrentActivePersona callback available');
+        }
+        // Fallback to activePersona from context
+        if (this.context.activePersona?.id) {
+            this.logger.debug(`Using context.activePersona.id: ${this.context.activePersona.id}`);
+            return this.context.activePersona.id;
+        }
+        // Last resort: use stored currentPersona or default
+        this.logger.debug(`Using stored currentPersona: ${this.currentPersona || 'default'}`);
+        return this.currentPersona || 'default';
+    }
+    /**
+     * Handle persona change notification from MCP server
+     * This is called when 'as' tool or 'become' prompt changes the persona
+     */
+    async onPersonaChanged(newPersonaId) {
+        this.logger.info(`🔔 CALLBACK TRIGGERED: Persona changed to ${newPersonaId}, reloading plans...`);
+        console.log(`🔔 CALLBACK TRIGGERED: Persona changed to ${newPersonaId}`);
+        // Update current persona
+        this.currentPersona = newPersonaId;
+        // Clear current plans
+        this.plans.clear();
+        // Reload plans with new persona
+        const plansLoaded = await this.loadPlans();
+        this.logger.info(`Reloaded ${plansLoaded} plans for persona ${newPersonaId}`);
+        // Emit update event to refresh dashboard
+        this.eventEmitter.emit('update', {
+            type: 'persona-changed',
+            personaId: newPersonaId
+        });
+    }
+    /**
+     * Load plans from storage using PlanningService
+     */
+    async loadPlans() {
+        try {
+            // Create a PlanningService instance with the current context
+            const planningService = new PlanningService(this.context);
+            // List plans based on current view type
+            // Default to 'active' if no view type is set, unless showAll is true
+            const plans = await planningService.listPlans(this.currentViewType ? { type: this.currentViewType } :
+                this.showAll ? {} : { type: 'active' });
+            // Get the currently active plan ID
+            const activePlan = await planningService.getActivePlan();
+            this.activePlanId = activePlan?.id || null;
+            // Don't use a fallback - let the frontend handle selection
+            this.logger.info(`[PlanWatcher] Active plan ID: ${this.activePlanId || 'none'}, Active plan title: ${activePlan?.title || 'none'}`);
+            if (!plans || plans.length === 0) {
+                this.logger.info('No plans found');
+                return 0;
+            }
+            // Clear existing plans and load the new ones
+            this.plans.clear();
+            for (const plan of plans) {
+                // Store the plan with its id as the key
+                this.plans.set(plan.id, plan);
+            }
+            return this.plans.size;
+        }
+        catch (error) {
+            this.logger.error('Failed to load plans:', error);
+            return 0;
+        }
+    }
+    /**
+     * Start watching for plan file changes
+     */
+    async startWatching() {
+        // Set up polling interval to check for changes
+        const POLL_INTERVAL = 2000; // Check every 2 seconds
+        this.watchInterval = setInterval(async () => {
+            await this.checkForChanges();
+        }, POLL_INTERVAL);
+        // Initial snapshot
+        await this.updateFileSnapshot();
+    }
+    /**
+     * Check for changes in plan files without reloading data
+     */
+    async checkForChanges() {
+        try {
+            // Store previous plan state for comparison
+            const previousPlanIds = new Set(this.plans.keys());
+            const previousPlans = new Map();
+            for (const [id, plan] of this.plans) {
+                const typedPlan = plan;
+                if (typedPlan.lastUpdated) {
+                    previousPlans.set(id, typedPlan.lastUpdated);
+                }
+            }
+            // Create a temporary planning service to check current state without modifying this.plans
+            const planningService = new PlanningService(this.context);
+            const currentPlans = await planningService.listPlans(this.currentViewType ? { type: this.currentViewType } :
+                this.showAll ? {} : { type: 'active' });
+            // Build current state for comparison
+            const currentPlanIds = new Set(currentPlans.map(p => p.id));
+            const currentPlanData = new Map();
+            for (const plan of currentPlans) {
+                if (plan.lastUpdated) {
+                    currentPlanData.set(plan.id, plan.lastUpdated);
+                }
+            }
+            // Detect changes without reloading
+            let hasChanges = false;
+            // Check if plan count changed
+            if (previousPlanIds.size !== currentPlanIds.size) {
+                hasChanges = true;
+                this.logger.info(`Plan count changed: ${previousPlanIds.size} -> ${currentPlanIds.size}`);
+            }
+            // Check for added or removed plans
+            if (!hasChanges) {
+                for (const id of previousPlanIds) {
+                    if (!currentPlanIds.has(id)) {
+                        hasChanges = true;
+                        this.logger.info(`Plan removed: ${id}`);
+                        break;
+                    }
+                }
+                for (const id of currentPlanIds) {
+                    if (!previousPlanIds.has(id)) {
+                        hasChanges = true;
+                        this.logger.info(`Plan added: ${id}`);
+                        break;
+                    }
+                }
+            }
+            // Check for modified plans (different lastUpdated)
+            if (!hasChanges) {
+                for (const [id, currentUpdated] of currentPlanData) {
+                    const previousUpdated = previousPlans.get(id);
+                    if (!previousUpdated || previousUpdated !== currentUpdated) {
+                        hasChanges = true;
+                        this.logger.info(`Plan modified: ${id} (${previousUpdated} -> ${currentUpdated})`);
+                        break;
+                    }
+                }
+            }
+            // Only reload and emit SSE event if changes detected
+            if (hasChanges) {
+                this.logger.info('Changes detected - reloading plans and emitting update event');
+                // Reload our cached plans with the new data
+                await this.loadPlans();
+                // Emit SSE event to notify dashboard
+                this.eventEmitter.emit('update', {
+                    type: 'update',
+                    changeType: 'modified'
+                });
+            }
+            else {
+                this.logger.debug('No changes detected - skipping reload and SSE event');
+            }
+        }
+        catch (error) {
+            this.logger.error('Error checking for plan changes:', error);
+        }
+    }
+    /**
+     * Update the file snapshot (deprecated - kept for compatibility)
+     */
+    async updateFileSnapshot() {
+        // No longer needed as we use PlanningService directly
+        // Just load plans to ensure we have the latest data
+        await this.loadPlans();
+    }
+    /**
+     * Create the HTTP server for the dashboard
+     */
+    createHttpServer() {
+        return http.createServer((req, res) => {
+            const url = new globalThis.URL(req.url || '/', `http://localhost:${this.port}`);
+            // Add CORS headers for all requests
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept');
+            // Handle preflight requests
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            // Route handling
+            if (url.pathname === '/') {
+                this.serveDashboard(res);
+            }
+            else if (url.pathname === '/api/plans') {
+                // Support both old 'archived' param and new 'type' param
+                const typeParam = url.searchParams.get('type');
+                const archivedParam = url.searchParams.get('archived');
+                let planType;
+                if (typeParam === 'active' || typeParam === 'archived') {
+                    planType = typeParam;
+                }
+                else if (archivedParam === 'true') {
+                    planType = 'archived'; // Backward compatibility
+                }
+                else if (archivedParam === 'false') {
+                    planType = 'active'; // Backward compatibility
+                }
+                // If no param or invalid param, planType remains undefined (returns all)
+                this.servePlansApi(res, planType);
+            }
+            else if (url.pathname.startsWith('/api/plan/')) {
+                const pathParts = url.pathname.substring('/api/plan/'.length).split('/');
+                const planId = pathParts[0];
+                const action = pathParts[1];
+                // Handle plan management actions
+                if (req.method === 'POST' && action) {
+                    this.handlePlanAction(req, res, planId, action);
+                }
+                else if (req.method === 'DELETE' && !action) {
+                    this.handlePlanDelete(req, res, planId);
+                }
+                else {
+                    // Default GET request for plan details
+                    this.servePlanApi(planId, url, res);
+                }
+            }
+            else if (url.pathname === '/api/persona') {
+                this.servePersonaApi(req, res);
+            }
+            else if (url.pathname === '/events') {
+                this.serveEventStream(req, res);
+            }
+            else if (url.pathname.startsWith('/assets/') || url.pathname.endsWith('.js') || url.pathname.endsWith('.css')) {
+                // Serve static assets for React dashboard
+                this.serveStaticAsset(url.pathname, res);
+            }
+            else {
+                // For client-side routing, serve index.html for non-API routes
+                const dashboardPath = this.getReactDashboardPath();
+                if (dashboardPath && fs.existsSync(dashboardPath)) {
+                    this.serveReactDashboard(res);
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not Found');
+                }
+            }
+        });
+    }
+    /**
+     * Serve the main dashboard HTML
+     */
+    serveDashboard(res) {
+        // Check if React build exists
+        const dashboardPath = this.getReactDashboardPath();
+        if (dashboardPath && fs.existsSync(dashboardPath)) {
+            this.serveReactDashboard(res);
+        }
+        else {
+            // Fallback to legacy HTML dashboard
+            const html = this.loadDashboardHtml();
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(html);
+        }
+    }
+    /**
+     * Serve the plans list API
+     */
+    async servePlansApi(res, planType) {
+        // Update view type for background polling (but only after we load the new data)
+        this.showAll = planType === 'archived' || planType === undefined;
+        // Always clear and reload plans with the correct filter for API calls
+        this.plans.clear();
+        // Use existing context
+        // Load plans based on type (undefined means all)
+        const planningService = new PlanningService(this.context);
+        console.log(`[servePlansApi] Requesting plans with type: ${planType}`);
+        const plans = await planningService.listPlans(planType ? { type: planType } : {});
+        console.log(`[servePlansApi] Retrieved ${plans.length} plans:`, plans.map(p => ({ id: p.id, status: p.status })));
+        // Store the loaded plans (PlanningService already set the correct status based on folder)
+        for (const plan of plans) {
+            this.plans.set(plan.id, plan);
+        }
+        // NOW update the view type for background polling to prevent false change detection
+        this.currentViewType = planType;
+        // Get the currently active plan ID (if any)
+        const activePlan = await planningService.getActivePlan();
+        this.activePlanId = activePlan?.id || null;
+        const plansList = Array.from(this.plans.entries()).map(([id, plan]) => {
+            const typedPlan = plan;
+            const isActive = id === this.activePlanId;
+            return {
+                id,
+                name: typedPlan.title || typedPlan.name || 'Unnamed Plan',
+                status: typedPlan.status || 'unknown',
+                phaseCount: typedPlan.phases?.length || 0,
+                progress: this.calculateProgress(plan),
+                updatedAt: typedPlan.updatedAt,
+                isCurrentlyActive: isActive,
+                // Add debug info directly to each plan
+                _debug: {
+                    planId: id,
+                    activePlanId: this.activePlanId,
+                    isMatch: id === this.activePlanId
+                }
+            };
+        });
+        const response = {
+            plans: plansList,
+            persona: this.currentPersona,
+            activePlanId: this.activePlanId,
+            debug: {
+                activePlanIdBeforeLoad: this.activePlanId,
+                plansCount: this.plans.size,
+                showAll: this.showAll
+            }
+        };
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(response));
+    }
+    /**
+     * Serve a specific plan API
+     */
+    async servePlanApi(planId, url, res) {
+        const plan = this.plans.get(planId);
+        if (!plan) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Plan not found' }));
+            return;
+        }
+        // Check if we want the formatted report
+        const format = url.searchParams.get('format');
+        if (format === 'report') {
+            try {
+                // Use PlanningService to generate the status report
+                const planningService = new PlanningService(this.context);
+                const report = await planningService.generateStatusReport(plan);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    report,
+                    format: 'markdown'
+                }));
+            }
+            catch (error) {
+                this.logger.error('Failed to generate plan report:', error);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Failed to generate report' }));
+            }
+        }
+        else {
+            // Return raw JSON as before
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(plan));
+        }
+    }
+    /**
+     * Serve the persona API (GET current only)
+     */
+    servePersonaApi(req, res) {
+        if (req.method === 'GET') {
+            // Return current persona from MCP server via callback
+            const personaId = this.getCurrentPersonaId();
+            this.logger.debug(`/api/persona requested, returning: ${personaId}`);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                personaId: personaId
+            }));
+        }
+        else {
+            // Persona changes are handled by MCP server via 'as' tool or 'become' prompt
+            // The dashboard will detect changes automatically via polling
+            res.writeHead(405, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'Method not allowed. Use the "as" tool or "become" prompt to change personas.'
+            }));
+        }
+    }
+    /**
+     * Handle plan management actions (archive, unarchive, activate)
+     */
+    async handlePlanAction(_req, res, planId, action) {
+        try {
+            // Use existing context
+            const planningService = new PlanningService(this.context);
+            let success = false;
+            let errorMessage = '';
+            try {
+                switch (action) {
+                    case 'archive':
+                        await planningService.archivePlan({ planId, reason: 'Archived via dashboard' });
+                        success = true;
+                        break;
+                    case 'unarchive':
+                        await planningService.unarchivePlan(planId);
+                        success = true;
+                        break;
+                    case 'activate':
+                        this.logger.info(`Attempting to switch to plan: ${planId} for persona: ${this.currentPersona}`);
+                        await planningService.switchToPlan(planId);
+                        success = true;
+                        this.logger.info(`Successfully switched to plan: ${planId}`);
+                        break;
+                    default:
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: `Unknown action: ${action}` }));
+                        return;
+                }
+            }
+            catch (error) {
+                success = false;
+                errorMessage = error instanceof Error ? error.message : 'Operation failed';
+                this.logger.error(`Error in plan action ${action} for ${planId}: ${errorMessage}`, error);
+            }
+            if (success) {
+                // Reload plans to reflect changes
+                await this.loadPlans();
+                // Send success response
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true, message: `Plan ${action}d successfully` }));
+                // Emit update event for real-time sync
+                this.eventEmitter.emit('update', { type: 'update', planId, action });
+            }
+            else {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: errorMessage || `Failed to ${action} plan` }));
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error handling plan action ${action} for ${planId}:`, error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    }
+    /**
+     * Handle plan deletion
+     */
+    async handlePlanDelete(_req, res, planId) {
+        try {
+            // Use existing context
+            const planningService = new PlanningService(this.context);
+            // Check if plan exists and is archived
+            const plan = this.plans.get(planId);
+            if (!plan) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Plan not found' }));
+                return;
+            }
+            // Type assertion since we know the structure
+            const planData = plan;
+            if (planData.type !== 'archived') {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Only archived plans can be deleted' }));
+                return;
+            }
+            try {
+                const result = await planningService.deletePlan(planId);
+                if (result) {
+                    // Reload plans to reflect changes
+                    await this.loadPlans();
+                    // Send success response
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true, message: 'Plan deleted successfully' }));
+                    // Emit update event for real-time sync
+                    this.eventEmitter.emit('update', { type: 'update', planId, action: 'delete' });
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Failed to delete plan' }));
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to delete plan';
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: errorMessage }));
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error deleting plan ${planId}:`, error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    }
+    /**
+     * Serve Server-Sent Events for real-time updates
+     */
+    serveEventStream(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type'
+        });
+        // Track this connection
+        this.activeConnections.add(res);
+        // Send initial connection message
+        res.write('data: {"type":"connected"}\n\n');
+        // Keep-alive ping every 30 seconds
+        const keepAlive = setInterval(() => {
+            res.write(':ping\n\n');
+        }, 30000);
+        // Listen for plan updates
+        const updateHandler = (data) => {
+            try {
+                res.write(`data: ${JSON.stringify(data)}\n\n`);
+            }
+            catch {
+                // Connection might be closed
+            }
+        };
+        this.eventEmitter.on('update', updateHandler);
+        // Clean up on client disconnect
+        req.on('close', () => {
+            clearInterval(keepAlive);
+            this.eventEmitter.off('update', updateHandler);
+            this.activeConnections.delete(res);
+        });
+    }
+    /**
+     * Calculate progress percentage for a plan
+     */
+    calculateProgress(plan) {
+        const typedPlan = plan;
+        if (!typedPlan.phases || typedPlan.phases.length === 0)
+            return 0;
+        const completedPhases = typedPlan.phases.filter((p) => p.status === 'completed').length;
+        return Math.round((completedPhases / typedPlan.phases.length) * 100);
+    }
+    /**
+     * Load and process the dashboard HTML
+     */
+    loadDashboardHtml() {
+        try {
+            // Get the directory of the current module
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // Read the dashboard HTML file
+            const htmlPath = path.join(__dirname, 'dashboard.html');
+            let html = fs.readFileSync(htmlPath, 'utf-8');
+            // Replace template variables
+            html = html.replace(/{{CURRENT_PERSONA}}/g, this.currentPersona);
+            return html;
+        }
+        catch (error) {
+            this.logger.error('Failed to load dashboard HTML:', error);
+            // Fallback to a simple error page
+            return this.generateFallbackHtml();
+        }
+    }
+    /**
+     * Generate fallback HTML if dashboard.html cannot be loaded
+     */
+    generateFallbackHtml() {
+        return `<!DOCTYPE html>
+<html>
+<head><title>Error</title></head>
+<body>
+  <h1>Dashboard Error</h1>
+  <p>Failed to load dashboard. Please check the logs.</p>
+  <p>Current persona: ${this.currentPersona}</p>
+</body>
+</html>`;
+    }
+    /**
+     * Get the path to the React dashboard build
+     */
+    getReactDashboardPath() {
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = path.dirname(__filename);
+            // Try production build location first
+            const prodPath = path.join(__dirname, '..', '..', 'dashboard');
+            if (fs.existsSync(path.join(prodPath, 'index.html'))) {
+                return prodPath;
+            }
+            // Try development build location
+            const devPath = path.join(__dirname, '..', '..', '..', 'tiny-brain-dashboard', 'dist');
+            if (fs.existsSync(path.join(devPath, 'index.html'))) {
+                return devPath;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('Failed to locate React dashboard:', error);
+            return null;
+        }
+    }
+    /**
+     * Serve the React dashboard
+     */
+    serveReactDashboard(res) {
+        const dashboardPath = this.getReactDashboardPath();
+        if (!dashboardPath) {
+            this.serveDashboard(res);
+            return;
+        }
+        const indexPath = path.join(dashboardPath, 'index.html');
+        const html = fs.readFileSync(indexPath, 'utf-8');
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+    }
+    /**
+     * Serve static assets for React dashboard
+     */
+    serveStaticAsset(urlPath, res) {
+        const dashboardPath = this.getReactDashboardPath();
+        if (!dashboardPath) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        // Remove leading slash and resolve path
+        const assetPath = path.join(dashboardPath, urlPath.substring(1));
+        // Security: Ensure the path is within the dashboard directory
+        if (!assetPath.startsWith(dashboardPath)) {
+            res.writeHead(403);
+            res.end('Forbidden');
+            return;
+        }
+        if (!fs.existsSync(assetPath)) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        // Determine content type
+        const ext = path.extname(assetPath).toLowerCase();
+        const contentTypes = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+        };
+        const contentType = contentTypes[ext] || 'application/octet-stream';
+        try {
+            const content = fs.readFileSync(assetPath);
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+        catch (error) {
+            this.logger.error('Failed to serve static asset:', error);
+            res.writeHead(500);
+            res.end('Internal Server Error');
+        }
+    }
+}
+//# sourceMappingURL=plan-watcher.service.js.map