Restructure Project Architecture with Modular Routes and Configuration

- Refactored main application entry point to use centralized configuration
- Created modular route structure with separate files for different API endpoints
- Introduced app.config.ts for centralized environment variable management
- Moved tools and route logic into dedicated files
- Simplified index.ts and improved overall project organization
- Added comprehensive type definitions for tools and API interactions

src/routes/health.routes.ts

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+import { APP_CONFIG } from '../config/app.config.js';
+
+const router = Router();
+
+// Health check endpoint
+router.get('/', (_req, res) => {
+    res.json({
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        version: APP_CONFIG.VERSION
+    });
+});
+
+export { router as healthRoutes }; 

src/routes/index.ts

@@ -0,0 +1,39 @@
+/**
+ * API Routes Module
+ * 
+ * This module exports the main router that combines all API routes
+ * into a single router instance. Each route group is mounted under
+ * its respective path prefix.
+ * 
+ * @module routes
+ */
+
+import { Router } from 'express';
+import { mcpRoutes } from './mcp.routes';
+import { sseRoutes } from './sse.routes';
+import { toolRoutes } from './tool.routes';
+import { healthRoutes } from './health.routes';
+
+/**
+ * Create main router instance
+ * This router will be mounted at /api in the main application
+ */
+const router = Router();
+
+/**
+ * Mount all route groups
+ * - /mcp: MCP schema and execution endpoints
+ * - /sse: Server-Sent Events endpoints
+ * - /tools: Tool management endpoints
+ * - /health: Health check endpoint
+ */
+router.use('/mcp', mcpRoutes);
+router.use('/sse', sseRoutes);
+router.use('/tools', toolRoutes);
+router.use('/health', healthRoutes);
+
+/**
+ * Export the configured router
+ * This will be mounted in the main application
+ */
+export { router as apiRoutes }; 

src/routes/mcp.routes.ts

@@ -0,0 +1,51 @@
+import { Router } from 'express';
+import { MCP_SCHEMA } from '../mcp/schema.js';
+import { APP_CONFIG } from '../config/app.config.js';
+import { Tool } from '../types/index.js';
+
+const router = Router();
+
+// Array to track tools
+const tools: Tool[] = [];
+
+// MCP schema endpoint - no auth required as it's just the schema
+router.get('/', (_req, res) => {
+    res.json(MCP_SCHEMA);
+});
+
+// MCP execute endpoint - requires authentication
+router.post('/execute', async (req, res) => {
+    try {
+        // Get token from Authorization header
+        const token = req.headers.authorization?.replace('Bearer ', '');
+
+        if (!token || token !== APP_CONFIG.HASS_TOKEN) {
+            return res.status(401).json({
+                success: false,
+                message: 'Unauthorized - Invalid token'
+            });
+        }
+
+        const { tool: toolName, parameters } = req.body;
+
+        // Find the requested tool
+        const tool = tools.find(t => t.name === toolName);
+        if (!tool) {
+            return res.status(404).json({
+                success: false,
+                message: `Tool '${toolName}' not found`
+            });
+        }
+
+        // Execute the tool with the provided parameters
+        const result = await tool.execute(parameters);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error occurred'
+        });
+    }
+});
+
+export { router as mcpRoutes }; 

src/routes/sse.routes.ts

@@ -0,0 +1,99 @@
+import { Router } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import { sseManager } from '../sse/index.js';
+import { TokenManager } from '../security/index.js';
+
+const router = Router();
+
+// SSE endpoints
+router.get('/subscribe', (req, res) => {
+    try {
+        // Get token from query parameter
+        const token = req.query.token?.toString();
+
+        if (!token || !TokenManager.validateToken(token)) {
+            return res.status(401).json({
+                success: false,
+                message: 'Unauthorized - Invalid token'
+            });
+        }
+
+        // Set SSE headers
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*'
+        });
+
+        // Send initial connection message
+        res.write(`data: ${JSON.stringify({
+            type: 'connection',
+            status: 'connected',
+            timestamp: new Date().toISOString()
+        })}\n\n`);
+
+        const clientId = uuidv4();
+        const client = {
+            id: clientId,
+            send: (data: string) => {
+                res.write(`data: ${data}\n\n`);
+            }
+        };
+
+        // Add client to SSE manager
+        const sseClient = sseManager.addClient(client, token);
+        if (!sseClient || !sseClient.authenticated) {
+            res.write(`data: ${JSON.stringify({
+                type: 'error',
+                message: sseClient ? 'Authentication failed' : 'Maximum client limit reached',
+                timestamp: new Date().toISOString()
+            })}\n\n`);
+            return res.end();
+        }
+
+        // Subscribe to events if specified
+        const events = req.query.events?.toString().split(',').filter(Boolean);
+        if (events?.length) {
+            events.forEach(event => sseManager.subscribeToEvent(clientId, event));
+        }
+
+        // Subscribe to entity if specified
+        const entityId = req.query.entity_id?.toString();
+        if (entityId) {
+            sseManager.subscribeToEntity(clientId, entityId);
+        }
+
+        // Subscribe to domain if specified
+        const domain = req.query.domain?.toString();
+        if (domain) {
+            sseManager.subscribeToDomain(clientId, domain);
+        }
+
+        // Handle client disconnect
+        req.on('close', () => {
+            sseManager.removeClient(clientId);
+        });
+
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error occurred'
+        });
+    }
+});
+
+// Get SSE stats endpoint
+router.get('/stats', async (req, res) => {
+    try {
+        const stats = await sseManager.getStats();
+        res.json(stats);
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error occurred'
+        });
+    }
+});
+
+export { router as sseRoutes }; 

src/routes/tool.routes.ts

@@ -0,0 +1,75 @@
+import { Router } from 'express';
+import { APP_CONFIG } from '../config/app.config.js';
+import { Tool } from '../types/index.js';
+
+const router = Router();
+
+// Array to track tools
+const tools: Tool[] = [];
+
+// List devices endpoint
+router.get('/devices', async (req, res) => {
+    try {
+        // Get token from Authorization header
+        const token = req.headers.authorization?.replace('Bearer ', '');
+
+        if (!token || token !== APP_CONFIG.HASS_TOKEN) {
+            return res.status(401).json({
+                success: false,
+                message: 'Unauthorized - Invalid token'
+            });
+        }
+
+        const tool = tools.find(t => t.name === 'list_devices');
+        if (!tool) {
+            return res.status(404).json({
+                success: false,
+                message: 'Tool not found'
+            });
+        }
+
+        const result = await tool.execute({ token });
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error occurred'
+        });
+    }
+});
+
+// Control device endpoint
+router.post('/control', async (req, res) => {
+    try {
+        // Get token from Authorization header
+        const token = req.headers.authorization?.replace('Bearer ', '');
+
+        if (!token || token !== APP_CONFIG.HASS_TOKEN) {
+            return res.status(401).json({
+                success: false,
+                message: 'Unauthorized - Invalid token'
+            });
+        }
+
+        const tool = tools.find(t => t.name === 'control');
+        if (!tool) {
+            return res.status(404).json({
+                success: false,
+                message: 'Tool not found'
+            });
+        }
+
+        const result = await tool.execute({
+            ...req.body,
+            token
+        });
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error occurred'
+        });
+    }
+});
+
+export { router as toolRoutes };