@magic-ingredients/tiny-brain-local 0.8.0 → 0.10.2

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

@@ -1,1010 +0,0 @@
-/**
- * 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 { PlanningService } from '@magic-ingredients/tiny-brain-core';
-/**
- * Singleton instance tracking
- */
-let runningInstance = null;
-/**
- * Plan Watcher Service
- */
-export class PlanWatcherService {
-    server = null;
-    watchInterval = null;
-    port = 0;
-    eventEmitter = new EventEmitter();
-    context;
-    logger;
-    activeConnections = new Set();
-    boundOnPersonaChanged = null;
-    // File timestamp tracking for change detection (only tracks timestamps, not content)
-    fileTimestamps = new Map();
-    // Track last known persona for change detection
-    lastKnownPersona = null;
-    constructor(context) {
-        this.context = context;
-        this.logger = context.logger;
-        this.logger.info('PlanWatcherService initialized (stateless mode)');
-    }
-    /**
-     * 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')
-                };
-            }
-            // Register persona change listener to detect changes
-            if (this.context.personaChangeListeners) {
-                this.boundOnPersonaChanged = this.onPersonaChanged.bind(this);
-                this.context.personaChangeListeners.push(this.boundOnPersonaChanged);
-                this.logger.info('Registered persona change listener');
-            }
-            // Set options
-            this.port = options.port || 8765;
-            const autoOpen = options.autoOpen !== undefined
-                ? options.autoOpen
-                : true; // Default to true
-            // No need to load plans initially - they'll be loaded on demand
-            // 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) {
-                // Browser opening functionality removed - user can manually open the URL
-                this.logger.info(`Dashboard available at ${url} - please open manually`);
-            }
-            return {
-                success: true,
-                data: {
-                    url,
-                    port: this.port,
-                    autoOpen,
-                    plansLoaded: 0 // Plans are loaded on demand now
-                }
-            };
-        }
-        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 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 tracking data
-            this.fileTimestamps.clear();
-            this.lastKnownPersona = null;
-            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 (stateless)
-     * Uses the callback to always get the latest persona from MCP server
-     */
-    getCurrentPersonaId() {
-        this.logger.debug('getCurrentPersonaId called');
-        // Use callback if available
-        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;
-        }
-        // Default if no persona available
-        this.logger.debug('Using default persona');
-        return '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}`);
-        // CRITICAL: Update the context's active persona so PlanningService loads the right plans
-        if (this.context.activePersona) {
-            this.context.activePersona.id = newPersonaId;
-        }
-        else {
-            // Create a minimal persona object if it doesn't exist
-            this.context.activePersona = {
-                id: newPersonaId,
-                userContent: {}
-            };
-        }
-        // Clear file timestamps since we're switching personas
-        this.fileTimestamps.clear();
-        // Emit SSE event to notify frontend of persona change
-        this.logger.info(`Emitting persona-changed event for: ${newPersonaId}`);
-        this.eventEmitter.emit('update', {
-            type: 'persona-changed',
-            personaId: newPersonaId,
-            changeType: 'persona',
-            message: `Persona changed to ${newPersonaId}`
-        });
-    }
-    /**
-     * Load plans from storage using PlanningService (stateless)
-     * Returns plans directly without storing them
-     */
-    async loadPlans(type) {
-        try {
-            // The context should already have the active persona from the MCP layer
-            const planningService = new PlanningService(this.context);
-            // Load plans based on type
-            const plans = type ?
-                await planningService.listPlans({ type }) :
-                await planningService.listPlans(); // Get all plans
-            // Get the currently active plan ID
-            const activePlan = await planningService.getActivePlan();
-            const activePlanId = activePlan?.id || null;
-            this.logger.info(`[loadPlans] Loaded ${plans.length} plans, active: ${activePlanId || 'none'}`);
-            return { plans, activePlanId };
-        }
-        catch (error) {
-            this.logger.error('Failed to load plans:', error);
-            return { plans: [], activePlanId: null };
-        }
-    }
-    /**
-     * 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
-     */
-    async checkForChanges() {
-        try {
-            // Skip checking if no active persona yet
-            if (!this.context.activePersona?.id) {
-                this.logger.debug('No active persona, skipping plan check');
-                return;
-            }
-            // Get current persona to check for changes
-            const currentPersona = this.getCurrentPersonaId();
-            // Check if persona changed
-            if (this.lastKnownPersona && this.lastKnownPersona !== currentPersona) {
-                this.logger.info(`Persona changed from ${this.lastKnownPersona} to ${currentPersona}`);
-                this.lastKnownPersona = currentPersona;
-                // Clear timestamps as we're in a new persona context
-                this.fileTimestamps.clear();
-                // Load all plans for the new persona
-                const { plans, activePlanId } = await this.loadPlans();
-                // Emit persona change event with full plan data
-                this.eventEmitter.emit('update', {
-                    type: 'personaChange',
-                    personaId: currentPersona,
-                    plans: plans, // Full plan data
-                    activePlanId: activePlanId,
-                    timestamp: new Date().toISOString()
-                });
-                return;
-            }
-            // Update last known persona if not set
-            if (!this.lastKnownPersona) {
-                this.lastKnownPersona = currentPersona;
-            }
-            // Load current plans to check for changes
-            // The context should already have the active persona from the MCP layer
-            const planningService = new PlanningService(this.context);
-            const currentPlans = await planningService.listPlans();
-            // Build current state map for comparison
-            const currentTimestamps = new Map();
-            for (const plan of currentPlans) {
-                // Use lastUpdated timestamp or a hash of the plan content
-                const timestamp = plan.lastUpdated ?
-                    new Date(plan.lastUpdated).getTime() :
-                    JSON.stringify(plan).length; // Simple content hash
-                currentTimestamps.set(plan.id, timestamp);
-            }
-            // Detect changes by comparing timestamps and track specific changes
-            let hasChanges = false;
-            const changedPlanIds = [];
-            const removedPlanIds = [];
-            // Check if the number of plans changed
-            if (this.fileTimestamps.size !== currentTimestamps.size) {
-                hasChanges = true;
-                this.logger.info(`Plan count changed: ${this.fileTimestamps.size} -> ${currentTimestamps.size}`);
-            }
-            // Check for removed plans
-            for (const [id] of this.fileTimestamps) {
-                if (!currentTimestamps.has(id)) {
-                    hasChanges = true;
-                    removedPlanIds.push(id);
-                    this.logger.info(`Plan removed: ${id}`);
-                }
-            }
-            // Check for added or modified plans
-            for (const [id, timestamp] of currentTimestamps) {
-                const previousTimestamp = this.fileTimestamps.get(id);
-                if (!previousTimestamp) {
-                    hasChanges = true;
-                    changedPlanIds.push(id);
-                    this.logger.info(`Plan added: ${id}`);
-                }
-                else if (previousTimestamp !== timestamp) {
-                    hasChanges = true;
-                    changedPlanIds.push(id);
-                    this.logger.info(`Plan modified: ${id}`);
-                }
-            }
-            // Update our timestamp tracking
-            this.fileTimestamps = currentTimestamps;
-            // Emit SSE event if changes detected
-            if (hasChanges) {
-                this.logger.info(`Changes detected - loading ${changedPlanIds.length} changed plans, ${removedPlanIds.length} removed`);
-                // Load only the changed plans (new or modified)
-                const changedPlans = [];
-                for (const planId of changedPlanIds) {
-                    const plan = currentPlans.find(p => p.id === planId);
-                    if (plan) {
-                        changedPlans.push(plan);
-                    }
-                }
-                // Get the active plan ID
-                const planningService = new PlanningService(this.context);
-                const activePlan = await planningService.getActivePlan();
-                const activePlanId = activePlan?.id || null;
-                const eventData = {
-                    type: 'planChange',
-                    changedPlans: changedPlans, // Only the plans that changed (with full content)
-                    removedPlanIds: removedPlanIds, // IDs of deleted plans
-                    activePlanId: activePlanId,
-                    personaId: this.getCurrentPersonaId(),
-                    changeType: 'incremental', // Indicates this is a partial update
-                    timestamp: new Date().toISOString(),
-                    version: 'v3-incremental' // New version with incremental updates
-                };
-                this.logger.info(`Emitting planChange event: ${changedPlans.length} changed, ${removedPlanIds.length} removed`);
-                this.eventEmitter.emit('update', eventData);
-            }
-            else {
-                this.logger.debug('No changes detected');
-            }
-        }
-        catch (error) {
-            this.logger.error('Error checking for plan changes:', error);
-        }
-    }
-    /**
-     * Update the file snapshot for change detection
-     */
-    async updateFileSnapshot() {
-        try {
-            // Load current plans to get initial timestamps
-            // The context should already have the active persona from the MCP layer
-            const planningService = new PlanningService(this.context);
-            const currentPlans = await planningService.listPlans();
-            // Build initial timestamp map
-            this.fileTimestamps.clear();
-            for (const plan of currentPlans) {
-                const timestamp = plan.lastUpdated ?
-                    new Date(plan.lastUpdated).getTime() :
-                    JSON.stringify(plan).length;
-                this.fileTimestamps.set(plan.id, timestamp);
-            }
-            // Store initial persona
-            this.lastKnownPersona = this.getCurrentPersonaId();
-            this.logger.info(`Initial snapshot: ${currentPlans.length} plans, persona: ${this.lastKnownPersona}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to update file snapshot:', error);
-        }
-    }
-    /**
-     * 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 (stateless - fetches fresh data)
-     */
-    async servePlansApi(res, planType) {
-        try {
-            // Load plans based on type (undefined means all)
-            // The context should already have the active persona from the MCP layer
-            const planningService = new PlanningService(this.context);
-            this.logger.debug(`[servePlansApi] Requesting plans with type: ${planType}`);
-            const plans = await planningService.listPlans(planType ? { type: planType } : {});
-            this.logger.debug(`[servePlansApi] Retrieved ${plans.length} plans`);
-            // Get the currently active plan ID
-            const activePlan = await planningService.getActivePlan();
-            const activePlanId = activePlan?.id || null;
-            // Get current persona
-            const currentPersona = this.getCurrentPersonaId();
-            // Transform plans to API format with full data
-            // The plan object from PlanningService might be typed as Plan which limits fields
-            // We need to treat it as a raw object to preserve ALL fields from the JSON file
-            const plansList = plans.map((plan) => {
-                const isTheCurrent = plan.id === activePlanId;
-                // Cast plan to any to access all fields from the JSON
-                const planAsAny = plan;
-                // Return the FULL plan object with computed fields
-                return {
-                    // Spread ALL fields from the original plan JSON
-                    ...planAsAny,
-                    // Add our computed/additional fields
-                    isTheCurrentPlan: isTheCurrent,
-                    name: planAsAny.title || 'Unnamed Plan',
-                    phaseCount: planAsAny.phases?.length || 0,
-                    progress: this.calculateProgress(planAsAny)
-                };
-            });
-            // Log the first plan to see what we're actually sending
-            if (plansList.length > 0) {
-                const firstPlan = plansList[0];
-                this.logger.debug(`First plan has phases: ${!!firstPlan.phases}`);
-                this.logger.debug(`First plan phases length: ${firstPlan.phases?.length}`);
-                this.logger.debug(`First plan keys before JSON.stringify: ${Object.keys(firstPlan).join(', ')}`);
-                // Test JSON serialization
-                const testJson = JSON.stringify(firstPlan);
-                const parsed = JSON.parse(testJson);
-                this.logger.debug(`First plan keys after JSON round-trip: ${Object.keys(parsed).join(', ')}`);
-            }
-            const response = {
-                plans: plansList,
-                persona: currentPersona,
-                activePlanId: activePlanId
-            };
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(response));
-        }
-        catch (error) {
-            this.logger.error('Error serving plans API:', error);
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Failed to load plans' }));
-        }
-    }
-    /**
-     * Serve a specific plan API
-     */
-    async servePlanApi(planId, url, res) {
-        // ALWAYS load from storage - it's local and fast!
-        // The context should already have the active persona from the MCP layer
-        const planningService = new PlanningService(this.context);
-        let plan;
-        try {
-            plan = await planningService.loadPlan({ planId });
-        }
-        catch (error) {
-            this.logger.error(`[servePlanApi] Error loading plan ${planId}:`, error);
-        }
-        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
-                // Context already has activePersona from above
-                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 /api/persona - Get current persona and their plans
-     */
-    async servePersonaApi(req, res) {
-        if (req.method === 'GET') {
-            // Get current persona
-            let personaId;
-            if (this.context.getCurrentActivePersona) {
-                personaId = this.context.getCurrentActivePersona() || 'default';
-                this.logger.info(`/api/persona - callback returned: ${personaId}`);
-            }
-            else {
-                // Fallback if no callback available
-                personaId = this.getCurrentPersonaId();
-                this.logger.warn(`/api/persona - no callback, using fallback: ${personaId}`);
-            }
-            // Also load the persona's plans for convenience
-            const { plans, activePlanId } = await this.loadPlans();
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                personaId: personaId,
-                plans: plans,
-                activePlanId: activePlanId
-            }));
-        }
-        else {
-            // Persona changes are handled by MCP server via 'as' tool
-            res.writeHead(405, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                error: 'Method not allowed. Use the "as" MCP tool to change personas.'
-            }));
-        }
-    }
-    /**
-     * Handle plan management actions (archive, unarchive, activate)
-     */
-    async handlePlanAction(_req, res, planId, action) {
-        try {
-            // The context should already have the active persona from the MCP layer
-            if (!this.context.activePersona) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'No active persona' }));
-                return;
-            }
-            const planningService = new PlanningService(this.context);
-            let success = false;
-            let errorMessage = '';
-            let newActivePlanId = null;
-            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(`Setting active plan to: ${planId}`);
-                        await planningService.switchToPlan(planId);
-                        newActivePlanId = planId;
-                        success = true;
-                        this.logger.info(`Active plan is now: ${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) {
-                // Return success response
-                const response = {
-                    success: true,
-                    message: `Plan ${action}d successfully`
-                };
-                if (newActivePlanId) {
-                    response.activePlanId = newActivePlanId;
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(response));
-                // Emit planChange event for real-time sync with full data
-                const { plans, activePlanId } = await this.loadPlans();
-                this.eventEmitter.emit('update', {
-                    type: 'planChange',
-                    plans: plans,
-                    activePlanId: activePlanId,
-                    personaId: this.getCurrentPersonaId(),
-                    action,
-                    planId,
-                    timestamp: new Date().toISOString()
-                });
-            }
-            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 {
-            // The context should already have the active persona from the MCP layer
-            if (!this.context.activePersona) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'No active persona' }));
-                return;
-            }
-            this.context.logger.info(`Attempting to delete plan ${planId} for persona ${this.context.activePersona.id}`);
-            try {
-                // Use PlanningService to delete the plan
-                // It will handle all the checks (archived status, ownership, etc.)
-                const planningService = new PlanningService(this.context);
-                const result = await planningService.deletePlan(planId);
-                if (result) {
-                    this.context.logger.info(`Successfully deleted plan ${planId}`);
-                    // Send success response
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ success: true, message: 'Plan deleted successfully' }));
-                    // Emit planChange event for real-time sync with full data
-                    const { plans, activePlanId } = await this.loadPlans();
-                    this.eventEmitter.emit('update', {
-                        type: 'planChange',
-                        plans: plans,
-                        activePlanId: activePlanId,
-                        personaId: this.getCurrentPersonaId(),
-                        action: 'delete',
-                        planId,
-                        timestamp: new Date().toISOString()
-                    });
-                }
-                else {
-                    // This shouldn't happen as deletePlan throws on error, but handle it just in case
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Failed to delete plan' }));
-                }
-            }
-            catch (error) {
-                // PlanningService will throw specific errors
-                const errorMessage = error instanceof Error ? error.message : 'Failed to delete plan';
-                this.context.logger.error(`Failed to delete plan: ${errorMessage}`);
-                if (errorMessage.includes('not found')) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Plan not found' }));
-                }
-                else if (errorMessage.includes('Archive it first')) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Only archived plans can be deleted' }));
-                }
-                else {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: errorMessage }));
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error deleting plan ${planId}:`, error);
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            // Return more specific error message
-            if (errorMessage.includes('not found') || errorMessage.includes('does not exist')) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Plan not found' }));
-            }
-            else {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: errorMessage }));
-            }
-        }
-    }
-    /**
-     * Serve Server-Sent Events for real-time updates
-     */
-    async 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);
-        // Get current persona and plans for initial sync
-        const currentPersona = this.getCurrentPersonaId();
-        this.logger.info(`New SSE connection - sending initial persona: ${currentPersona}`);
-        // Load initial plans to send with connected event
-        const { plans, activePlanId } = await this.loadPlans();
-        // Send initial connection message with current persona AND plans
-        res.write(`data: ${JSON.stringify({
-            type: 'connected',
-            personaId: currentPersona,
-            plans: plans, // Include all plans in connected event
-            activePlanId: activePlanId,
-            timestamp: new Date().toISOString()
-        })}\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 with current persona
-            const currentPersona = this.getCurrentPersonaId();
-            html = html.replace(/{{CURRENT_PERSONA}}/g, 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() {
-        const currentPersona = this.getCurrentPersonaId();
-        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: ${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 DXT bundle location first (server is at server/index.js, dashboard at dashboard/)
-            const dxtPath = path.join(__dirname, '..', 'dashboard');
-            if (fs.existsSync(path.join(dxtPath, 'index.html'))) {
-                this.logger.info(`Found dashboard at DXT location: ${dxtPath}`);
-                return dxtPath;
-            }
-            // Try production build location
-            const prodPath = path.join(__dirname, '..', '..', 'dashboard');
-            if (fs.existsSync(path.join(prodPath, 'index.html'))) {
-                this.logger.info(`Found dashboard at production location: ${prodPath}`);
-                return prodPath;
-            }
-            // Try development build location
-            const devPath = path.join(__dirname, '..', '..', '..', 'tiny-brain-dashboard', 'dist');
-            if (fs.existsSync(path.join(devPath, 'index.html'))) {
-                this.logger.info(`Found dashboard at development location: ${devPath}`);
-                return devPath;
-            }
-            this.logger.warn('Dashboard not found in any expected location');
-            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