refactor: optimize configuration and tool implementations

- Standardized error handling across tool implementations
- Improved return type consistency for tool execution results
- Simplified configuration parsing and type definitions
- Enhanced type safety for various configuration schemas
- Cleaned up and normalized tool response structures
- Updated SSE and event subscription tool implementations

Dockerfile

@@ -1,20 +1,23 @@
 # Use Bun as the base image
-FROM oven/bun:1.0.26
+FROM oven/bun:1.0.25
 
 # Set working directory
 WORKDIR /app
 
-# Copy source code
+# Copy package files
-COPY . .
+COPY package.json bun.lockb ./
 
 # Install dependencies
 RUN bun install
 
+# Copy source code
+COPY . .
+
 # Build TypeScript
 RUN bun run build
 
-# Expose the port the app runs on
+# Expose port
-EXPOSE 3000
+EXPOSE 4000
 
 # Start the application
 CMD ["bun", "run", "start"] 

package.json

@@ -16,7 +16,7 @@
     "prepare": "husky install"
   },
   "dependencies": {
-    "@digital-alchemy/core": "^0.1.0",
+    "@digital-alchemy/core": "^25.1.3",
     "@digital-alchemy/hass": "^25.1.1",
     "@jest/globals": "^29.7.0",
     "@types/express": "^4.17.21",

src/__mocks__/@digital-alchemy/hass.ts

@@ -1,77 +1,77 @@
-import { mock } from 'bun:test';
+import { mock } from "bun:test";
 
 export const LIB_HASS = {
   configuration: {
-        name: 'Home Assistant',
+    name: "Home Assistant",
-        version: '2024.2.0',
+    version: "2024.2.0",
-        location_name: 'Home',
+    location_name: "Home",
-        time_zone: 'UTC',
+    time_zone: "UTC",
-        components: ['automation', 'script', 'light', 'switch'],
+    components: ["automation", "script", "light", "switch"],
     unit_system: {
-            temperature: '°C',
+      temperature: "°C",
-            length: 'm',
+      length: "m",
-            mass: 'kg',
+      mass: "kg",
-            pressure: 'hPa',
+      pressure: "hPa",
-            volume: 'L'
+      volume: "L",
-        }
+    },
   },
   services: {
     light: {
       turn_on: mock(() => Promise.resolve()),
       turn_off: mock(() => Promise.resolve()),
-            toggle: mock(() => Promise.resolve())
+      toggle: mock(() => Promise.resolve()),
     },
     switch: {
       turn_on: mock(() => Promise.resolve()),
       turn_off: mock(() => Promise.resolve()),
-            toggle: mock(() => Promise.resolve())
+      toggle: mock(() => Promise.resolve()),
     },
     automation: {
       trigger: mock(() => Promise.resolve()),
       turn_on: mock(() => Promise.resolve()),
-            turn_off: mock(() => Promise.resolve())
+      turn_off: mock(() => Promise.resolve()),
     },
     script: {
       turn_on: mock(() => Promise.resolve()),
       turn_off: mock(() => Promise.resolve()),
-            toggle: mock(() => Promise.resolve())
+      toggle: mock(() => Promise.resolve()),
-        }
+    },
   },
   states: {
     light: {
-            'light.living_room': {
+      "light.living_room": {
-                state: 'on',
+        state: "on",
         attributes: {
           brightness: 255,
           color_temp: 300,
-                    friendly_name: 'Living Room Light'
+          friendly_name: "Living Room Light",
-                }
         },
-            'light.bedroom': {
+      },
-                state: 'off',
+      "light.bedroom": {
+        state: "off",
         attributes: {
-                    friendly_name: 'Bedroom Light'
+          friendly_name: "Bedroom Light",
-                }
+        },
-            }
+      },
     },
     switch: {
-            'switch.tv': {
+      "switch.tv": {
-                state: 'off',
+        state: "off",
         attributes: {
-                    friendly_name: 'TV'
+          friendly_name: "TV",
-                }
+        },
-            }
+      },
-        }
+    },
   },
   events: {
     subscribe: mock(() => Promise.resolve()),
     unsubscribe: mock(() => Promise.resolve()),
-        fire: mock(() => Promise.resolve())
+    fire: mock(() => Promise.resolve()),
   },
   connection: {
     subscribeEvents: mock(() => Promise.resolve()),
     subscribeMessage: mock(() => Promise.resolve()),
     sendMessage: mock(() => Promise.resolve()),
-        close: mock(() => Promise.resolve())
+    close: mock(() => Promise.resolve()),
-    }
+  },
 };

src/__mocks__/litemcp.ts

@@ -4,8 +4,8 @@ export class LiteMCP {
   config: any;
 
   constructor(config: any = {}) {
-        this.name = 'home-assistant';
+    this.name = "home-assistant";
-        this.version = '1.0.0';
+    this.version = "1.0.0";
     this.config = config;
   }
 
@@ -36,10 +36,10 @@ export class LiteMCP {
   async getState(entityId: string) {
     return Promise.resolve({
       entity_id: entityId,
-            state: 'unknown',
+      state: "unknown",
       attributes: {},
       last_changed: new Date().toISOString(),
-            last_updated: new Date().toISOString()
+      last_updated: new Date().toISOString(),
     });
   }
 

src/__tests__/setup.ts

@@ -1,15 +1,24 @@
-import { config } from 'dotenv';
+import { config } from "dotenv";
-import path from 'path';
+import path from "path";
-import { TEST_CONFIG } from '../config/__tests__/test.config';
+import { TEST_CONFIG } from "../config/__tests__/test.config";
-import { beforeAll, afterAll, beforeEach, describe, expect, it, mock, test } from 'bun:test';
+import {
+  beforeAll,
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+  test,
+} from "bun:test";
 
 // Load test environment variables
-config({ path: path.resolve(process.cwd(), '.env.test') });
+config({ path: path.resolve(process.cwd(), ".env.test") });
 
 // Global test setup
 beforeAll(() => {
   // Set required environment variables
-    process.env.NODE_ENV = 'test';
+  process.env.NODE_ENV = "test";
   process.env.JWT_SECRET = TEST_CONFIG.TEST_JWT_SECRET;
   process.env.TEST_TOKEN = TEST_CONFIG.TEST_TOKEN;
 
@@ -29,7 +38,7 @@ beforeAll(() => {
   (global as any).__ORIGINAL_CONSOLE__ = {
     error: originalConsoleError,
     warn: originalConsoleWarn,
-        log: originalConsoleLog
+    log: originalConsoleLog,
   };
 });
 
@@ -48,8 +57,10 @@ afterAll(() => {
 // Reset mocks between tests
 beforeEach(() => {
   // Clear all mock function calls
-    const mockFns = Object.values(mock).filter(value => typeof value === 'function');
+  const mockFns = Object.values(mock).filter(
-    mockFns.forEach(mockFn => {
+    (value) => typeof value === "function",
+  );
+  mockFns.forEach((mockFn) => {
     if (mockFn.mock) {
       mockFn.mock.calls = [];
       mockFn.mock.results = [];
@@ -67,7 +78,7 @@ const setupTestEnvironment = () => {
       const mockWs = {
         on: mock(() => {}),
         send: mock(() => {}),
-                close: mock(() => { })
+        close: mock(() => {}),
       };
       return mockWs;
     },
@@ -89,51 +100,54 @@ const setupTestEnvironment = () => {
     // Mock HTTP request for API tests
     mockRequest: (overrides = {}) => {
       return {
-                headers: { 'content-type': 'application/json' },
+        headers: { "content-type": "application/json" },
         body: {},
         query: {},
         params: {},
         ip: TEST_CONFIG.TEST_CLIENT_IP,
-                method: 'GET',
+        method: "GET",
-                path: '/api/test',
+        path: "/api/test",
-                is: mock((type: string) => type === 'application/json'),
+        is: mock((type: string) => type === "application/json"),
-                ...overrides
+        ...overrides,
       };
     },
 
     // Create test client for SSE tests
-        createTestClient: (id: string = 'test-client') => ({
+    createTestClient: (id: string = "test-client") => ({
       id,
       ip: TEST_CONFIG.TEST_CLIENT_IP,
       connectedAt: new Date(),
       send: mock(() => {}),
       rateLimit: {
         count: 0,
-                lastReset: Date.now()
+        lastReset: Date.now(),
       },
-            connectionTime: Date.now()
+      connectionTime: Date.now(),
     }),
 
     // Create test event for SSE tests
-        createTestEvent: (type: string = 'test_event', data: any = {}) => ({
+    createTestEvent: (type: string = "test_event", data: any = {}) => ({
       event_type: type,
       data,
-            origin: 'test',
+      origin: "test",
       time_fired: new Date().toISOString(),
-            context: { id: 'test' }
+      context: { id: "test" },
     }),
 
     // Create test entity for Home Assistant tests
-        createTestEntity: (entityId: string = 'test.entity', state: string = 'on') => ({
+    createTestEntity: (
+      entityId: string = "test.entity",
+      state: string = "on",
+    ) => ({
       entity_id: entityId,
       state,
       attributes: {},
       last_changed: new Date().toISOString(),
-            last_updated: new Date().toISOString()
+      last_updated: new Date().toISOString(),
     }),
 
     // Helper to wait for async operations
-        wait: (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+    wait: (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)),
   };
 };
 

src/ai/endpoints/ai-router.ts

@@ -1,8 +1,14 @@
-import express from 'express';
+import express from "express";
-import { z } from 'zod';
+import { z } from "zod";
-import { NLPProcessor } from '../nlp/processor.js';
+import { NLPProcessor } from "../nlp/processor.js";
-import { AIRateLimit, AIContext, AIResponse, AIError, AIModel } from '../types/index.js';
+import {
-import rateLimit from 'express-rate-limit';
+  AIRateLimit,
+  AIContext,
+  AIResponse,
+  AIError,
+  AIModel,
+} from "../types/index.js";
+import rateLimit from "express-rate-limit";
 
 const router = express.Router();
 const nlpProcessor = new NLPProcessor();
@@ -15,17 +21,17 @@ const rateLimitConfig: AIRateLimit = {
   model_specific_limits: {
     claude: {
       requests_per_minute: 100,
-            requests_per_hour: 1000
+      requests_per_hour: 1000,
     },
     gpt4: {
       requests_per_minute: 50,
-            requests_per_hour: 500
+      requests_per_hour: 500,
     },
     custom: {
       requests_per_minute: 200,
-            requests_per_hour: 2000
+      requests_per_hour: 2000,
-        }
+    },
-    }
+  },
 };
 
 // Request validation schemas
@@ -37,21 +43,23 @@ const interpretRequestSchema = z.object({
     timestamp: z.string(),
     location: z.string(),
     previous_actions: z.array(z.any()),
-        environment_state: z.record(z.any())
+    environment_state: z.record(z.any()),
   }),
-    model: z.enum(['claude', 'gpt4', 'custom']).optional()
+  model: z.enum(["claude", "gpt4", "custom"]).optional(),
 });
 
 // Rate limiters
 const globalLimiter = rateLimit({
   windowMs: 60 * 1000, // 1 minute
-    max: rateLimitConfig.requests_per_minute
+  max: rateLimitConfig.requests_per_minute,
 });
 
-const modelSpecificLimiter = (model: string) => rateLimit({
+const modelSpecificLimiter = (model: string) =>
+  rateLimit({
     windowMs: 60 * 1000,
-    max: rateLimitConfig.model_specific_limits[model as AIModel]?.requests_per_minute ||
+    max:
-        rateLimitConfig.requests_per_minute
+      rateLimitConfig.model_specific_limits[model as AIModel]
+        ?.requests_per_minute || rateLimitConfig.requests_per_minute,
   });
 
 // Error handler middleware
@@ -59,18 +67,18 @@ const errorHandler = (
   error: Error,
   req: express.Request,
   res: express.Response,
-    next: express.NextFunction
+  next: express.NextFunction,
 ) => {
   const aiError: AIError = {
-        code: 'PROCESSING_ERROR',
+    code: "PROCESSING_ERROR",
     message: error.message,
-        suggestion: 'Please try again with a different command format',
+    suggestion: "Please try again with a different command format",
     recovery_options: [
-            'Simplify your command',
+      "Simplify your command",
-            'Use standard command patterns',
+      "Use standard command patterns",
-            'Check device names and parameters'
+      "Check device names and parameters",
     ],
-        context: req.body.context
+    context: req.body.context,
   };
 
   res.status(500).json({ error: aiError });
@@ -78,15 +86,26 @@ const errorHandler = (
 
 // Endpoints
 router.post(
-    '/interpret',
+  "/interpret",
   globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
+    req: express.Request,
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
     try {
-            const { input, context, model = 'claude' } = interpretRequestSchema.parse(req.body);
+      const {
+        input,
+        context,
+        model = "claude",
+      } = interpretRequestSchema.parse(req.body);
 
       // Apply model-specific rate limiting
       modelSpecificLimiter(model)(req, res, async () => {
-                const { intent, confidence, error } = await nlpProcessor.processCommand(input, context);
+        const { intent, confidence, error } = await nlpProcessor.processCommand(
+          input,
+          context,
+        );
 
         if (error) {
           return res.status(400).json({ error });
@@ -96,39 +115,39 @@ router.post(
 
         if (!isValid) {
           const suggestions = await nlpProcessor.suggestCorrections(input, {
-                        code: 'INVALID_INTENT',
+            code: "INVALID_INTENT",
-                        message: 'Could not understand the command with high confidence',
+            message: "Could not understand the command with high confidence",
-                        suggestion: 'Please try rephrasing your command',
+            suggestion: "Please try rephrasing your command",
             recovery_options: [],
-                        context
+            context,
           });
 
           return res.status(400).json({
             error: {
-                            code: 'INVALID_INTENT',
+              code: "INVALID_INTENT",
-                            message: 'Could not understand the command with high confidence',
+              message: "Could not understand the command with high confidence",
-                            suggestion: 'Please try rephrasing your command',
+              suggestion: "Please try rephrasing your command",
               recovery_options: suggestions,
-                            context
+              context,
-                        }
+            },
           });
         }
 
         const response: AIResponse = {
-                    natural_language: `I'll ${intent.action} the ${intent.target.split('.').pop()}`,
+          natural_language: `I'll ${intent.action} the ${intent.target.split(".").pop()}`,
           structured_data: {
             success: true,
             action_taken: intent.action,
             entities_affected: [intent.target],
-                        state_changes: intent.parameters
+            state_changes: intent.parameters,
           },
           next_suggestions: [
-                        'Would you like to adjust any settings?',
+            "Would you like to adjust any settings?",
-                        'Should I perform this action in other rooms?',
+            "Should I perform this action in other rooms?",
-                        'Would you like to schedule this action?'
+            "Would you like to schedule this action?",
           ],
           confidence,
-                    context
+          context,
         };
 
         res.json(response);
@@ -136,15 +155,19 @@ router.post(
     } catch (error) {
       next(error);
     }
-    }
+  },
 );
 
 router.post(
-    '/execute',
+  "/execute",
   globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
+    req: express.Request,
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
     try {
-            const { intent, context, model = 'claude' } = req.body;
+      const { intent, context, model = "claude" } = req.body;
 
       // Apply model-specific rate limiting
       modelSpecificLimiter(model)(req, res, async () => {
@@ -157,15 +180,15 @@ router.post(
             success: true,
             action_taken: intent.action,
             entities_affected: [intent.target],
-                        state_changes: intent.parameters
+            state_changes: intent.parameters,
           },
           next_suggestions: [
-                        'Would you like to verify the state?',
+            "Would you like to verify the state?",
-                        'Should I perform any related actions?',
+            "Should I perform any related actions?",
-                        'Would you like to undo this action?'
+            "Would you like to undo this action?",
           ],
           confidence: { overall: 1, intent: 1, entities: 1, context: 1 },
-                    context
+          context,
         };
 
         res.json(response);
@@ -173,24 +196,28 @@ router.post(
     } catch (error) {
       next(error);
     }
-    }
+  },
 );
 
 router.get(
-    '/suggestions',
+  "/suggestions",
   globalLimiter,
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+  async (
+    req: express.Request,
+    res: express.Response,
+    next: express.NextFunction,
+  ) => {
     try {
-            const { context, model = 'claude' } = req.body;
+      const { context, model = "claude" } = req.body;
 
       // Apply model-specific rate limiting
       modelSpecificLimiter(model)(req, res, async () => {
         // Generate context-aware suggestions
         const suggestions = [
-                    'Turn on the lights in the living room',
+          "Turn on the lights in the living room",
-                    'Set the temperature to 72 degrees',
+          "Set the temperature to 72 degrees",
-                    'Show me the current state of all devices',
+          "Show me the current state of all devices",
-                    'Start the evening routine'
+          "Start the evening routine",
         ];
 
         res.json({ suggestions });
@@ -198,7 +225,7 @@ router.get(
     } catch (error) {
       next(error);
     }
-    }
+  },
 );
 
 // Apply error handler

src/ai/nlp/context-analyzer.ts

@@ -1,4 +1,4 @@
-import { AIContext, AIIntent } from '../types/index.js';
+import { AIContext, AIIntent } from "../types/index.js";
 
 interface ContextAnalysis {
   confidence: number;
@@ -19,9 +19,12 @@ export class ContextAnalyzer {
       // Location-based context
       {
         condition: (context, intent) =>
-                    Boolean(context.location && intent.target.includes(context.location.toLowerCase())),
+          Boolean(
+            context.location &&
+              intent.target.includes(context.location.toLowerCase()),
+          ),
         relevance: 0.8,
-                params: (context) => ({ location: context.location })
+        params: (context) => ({ location: context.location }),
       },
 
       // Time-based context
@@ -32,40 +35,46 @@ export class ContextAnalyzer {
         },
         relevance: 0.6,
         params: (context) => ({
-                    time_of_day: this.getTimeOfDay(new Date(context.timestamp))
+          time_of_day: this.getTimeOfDay(new Date(context.timestamp)),
-                })
+        }),
       },
 
       // Previous action context
       {
         condition: (context, intent) => {
           const recentActions = context.previous_actions.slice(-3);
-                    return recentActions.some(action =>
+          return recentActions.some(
+            (action) =>
               action.target === intent.target ||
-                        action.action === intent.action
+              action.action === intent.action,
           );
         },
         relevance: 0.7,
         params: (context) => ({
-                    recent_action: context.previous_actions[context.previous_actions.length - 1]
+          recent_action:
-                })
+            context.previous_actions[context.previous_actions.length - 1],
+        }),
       },
 
       // Environment state context
       {
         condition: (context, intent) => {
-                    return Object.keys(context.environment_state).some(key =>
+          return Object.keys(context.environment_state).some(
+            (key) =>
               intent.target.includes(key) ||
-                        intent.parameters[key] !== undefined
+              intent.parameters[key] !== undefined,
           );
         },
         relevance: 0.9,
-                params: (context) => ({ environment: context.environment_state })
+        params: (context) => ({ environment: context.environment_state }),
-            }
+      },
     ];
   }
 
-    async analyze(intent: AIIntent, context: AIContext): Promise<ContextAnalysis> {
+  async analyze(
+    intent: AIIntent,
+    context: AIContext,
+  ): Promise<ContextAnalysis> {
     let totalConfidence = 0;
     let relevantParams: Record<string, any> = {};
     let applicableRules = 0;
@@ -78,30 +87,29 @@ export class ContextAnalyzer {
         if (rule.params) {
           relevantParams = {
             ...relevantParams,
-                        ...rule.params(context)
+            ...rule.params(context),
           };
         }
       }
     }
 
     // Calculate normalized confidence
-        const confidence = applicableRules > 0
+    const confidence =
-            ? totalConfidence / applicableRules
+      applicableRules > 0 ? totalConfidence / applicableRules : 0.5; // Default confidence if no rules apply
-            : 0.5; // Default confidence if no rules apply
 
     return {
       confidence,
-            relevant_params: relevantParams
+      relevant_params: relevantParams,
     };
   }
 
   private getTimeOfDay(date: Date): string {
     const hour = date.getHours();
 
-        if (hour >= 5 && hour < 12) return 'morning';
+    if (hour >= 5 && hour < 12) return "morning";
-        if (hour >= 12 && hour < 17) return 'afternoon';
+    if (hour >= 12 && hour < 17) return "afternoon";
-        if (hour >= 17 && hour < 22) return 'evening';
+    if (hour >= 17 && hour < 22) return "evening";
-        return 'night';
+    return "night";
   }
 
   async updateContextRules(newRules: ContextRule[]): Promise<void> {
@@ -126,7 +134,10 @@ export class ContextAnalyzer {
     }
 
     // Validate environment state
-        if (typeof context.environment_state !== 'object' || context.environment_state === null) {
+    if (
+      typeof context.environment_state !== "object" ||
+      context.environment_state === null
+    ) {
       return false;
     }
 

src/ai/nlp/entity-extractor.ts

@@ -1,4 +1,4 @@
-import { AIContext } from '../types/index.js';
+import { AIContext } from "../types/index.js";
 
 interface ExtractedEntities {
   primary_target: string;
@@ -18,21 +18,24 @@ export class EntityExtractor {
 
   private initializePatterns(): void {
     // Device name variations
-        this.deviceNameMap.set('living room light', 'light.living_room');
+    this.deviceNameMap.set("living room light", "light.living_room");
-        this.deviceNameMap.set('kitchen light', 'light.kitchen');
+    this.deviceNameMap.set("kitchen light", "light.kitchen");
-        this.deviceNameMap.set('bedroom light', 'light.bedroom');
+    this.deviceNameMap.set("bedroom light", "light.bedroom");
 
     // Parameter patterns
-        this.parameterPatterns.set('brightness', /(\d+)\s*(%|percent)|bright(ness)?\s+(\d+)/i);
+    this.parameterPatterns.set(
-        this.parameterPatterns.set('temperature', /(\d+)\s*(degrees?|°)[CF]?/i);
+      "brightness",
-        this.parameterPatterns.set('color', /(red|green|blue|white|warm|cool)/i);
+      /(\d+)\s*(%|percent)|bright(ness)?\s+(\d+)/i,
+    );
+    this.parameterPatterns.set("temperature", /(\d+)\s*(degrees?|°)[CF]?/i);
+    this.parameterPatterns.set("color", /(red|green|blue|white|warm|cool)/i);
   }
 
   async extract(input: string): Promise<ExtractedEntities> {
     const entities: ExtractedEntities = {
-            primary_target: '',
+      primary_target: "",
       parameters: {},
-            confidence: 0
+      confidence: 0,
     };
 
     try {
@@ -48,7 +51,10 @@ export class EntityExtractor {
       for (const [param, pattern] of this.parameterPatterns) {
         const match = input.match(pattern);
         if (match) {
-                    entities.parameters[param] = this.normalizeParameterValue(param, match[1]);
+          entities.parameters[param] = this.normalizeParameterValue(
+            param,
+            match[1],
+          );
         }
       }
 
@@ -57,29 +63,35 @@ export class EntityExtractor {
 
       return entities;
     } catch (error) {
-            console.error('Entity extraction error:', error);
+      console.error("Entity extraction error:", error);
       return {
-                primary_target: '',
+        primary_target: "",
         parameters: {},
-                confidence: 0
+        confidence: 0,
       };
     }
   }
 
-    private normalizeParameterValue(parameter: string, value: string): number | string {
+  private normalizeParameterValue(
+    parameter: string,
+    value: string,
+  ): number | string {
     switch (parameter) {
-            case 'brightness':
+      case "brightness":
         return Math.min(100, Math.max(0, parseInt(value)));
-            case 'temperature':
+      case "temperature":
         return parseInt(value);
-            case 'color':
+      case "color":
         return value.toLowerCase();
       default:
         return value;
     }
   }
 
-    private calculateConfidence(entities: ExtractedEntities, input: string): number {
+  private calculateConfidence(
+    entities: ExtractedEntities,
+    input: string,
+  ): number {
     let confidence = 0;
 
     // Device confidence

src/ai/nlp/intent-classifier.ts

@@ -18,54 +18,47 @@ export class IntentClassifier {
   constructor() {
     this.actionPatterns = [
       {
-                action: 'turn_on',
+        action: "turn_on",
-                patterns: [
+        patterns: [/turn\s+on/i, /switch\s+on/i, /enable/i, /activate/i],
-                    /turn\s+on/i,
-                    /switch\s+on/i,
-                    /enable/i,
-                    /activate/i
-                ]
       },
       {
-                action: 'turn_off',
+        action: "turn_off",
-                patterns: [
+        patterns: [/turn\s+off/i, /switch\s+off/i, /disable/i, /deactivate/i],
-                    /turn\s+off/i,
-                    /switch\s+off/i,
-                    /disable/i,
-                    /deactivate/i
-                ]
       },
       {
-                action: 'set',
+        action: "set",
         patterns: [
           /set\s+(?:the\s+)?(.+)\s+to/i,
           /change\s+(?:the\s+)?(.+)\s+to/i,
-                    /adjust\s+(?:the\s+)?(.+)\s+to/i
+          /adjust\s+(?:the\s+)?(.+)\s+to/i,
         ],
-                parameters: ['brightness', 'temperature', 'color']
+        parameters: ["brightness", "temperature", "color"],
       },
       {
-                action: 'query',
+        action: "query",
         patterns: [
           /what\s+is/i,
           /get\s+(?:the\s+)?(.+)/i,
           /show\s+(?:the\s+)?(.+)/i,
-                    /tell\s+me/i
+          /tell\s+me/i,
-                ]
+        ],
-            }
+      },
     ];
   }
 
   async classify(
     input: string,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
+    extractedEntities: {
+      parameters: Record<string, any>;
+      primary_target: string;
+    },
   ): Promise<ClassifiedIntent> {
     let bestMatch: ClassifiedIntent = {
-            action: '',
+      action: "",
-            target: '',
+      target: "",
       confidence: 0,
       parameters: {},
-            raw_input: input
+      raw_input: input,
     };
 
     for (const actionPattern of this.actionPatterns) {
@@ -78,8 +71,12 @@ export class IntentClassifier {
               action: actionPattern.action,
               target: extractedEntities.primary_target,
               confidence,
-                            parameters: this.extractActionParameters(actionPattern, match, extractedEntities),
+              parameters: this.extractActionParameters(
-                            raw_input: input
+                actionPattern,
+                match,
+                extractedEntities,
+              ),
+              raw_input: input,
             };
           }
         }
@@ -105,7 +102,7 @@ export class IntentClassifier {
     }
 
     // Additional confidence for specific keywords
-        const keywords = ['please', 'can you', 'would you'];
+    const keywords = ["please", "can you", "would you"];
     for (const keyword of keywords) {
       if (input.toLowerCase().includes(keyword)) {
         confidence += 0.1;
@@ -118,7 +115,10 @@ export class IntentClassifier {
   private extractActionParameters(
     actionPattern: ActionPattern,
     match: RegExpMatchArray,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
+    extractedEntities: {
+      parameters: Record<string, any>;
+      primary_target: string;
+    },
   ): Record<string, any> {
     const parameters: Record<string, any> = {};
 
@@ -141,37 +141,40 @@ export class IntentClassifier {
 
   private inferFromContext(
     input: string,
-        extractedEntities: { parameters: Record<string, any>; primary_target: string }
+    extractedEntities: {
+      parameters: Record<string, any>;
+      primary_target: string;
+    },
   ): ClassifiedIntent {
     // Default to 'set' action if parameters are present
     if (Object.keys(extractedEntities.parameters).length > 0) {
       return {
-                action: 'set',
+        action: "set",
         target: extractedEntities.primary_target,
         confidence: 0.5,
         parameters: extractedEntities.parameters,
-                raw_input: input
+        raw_input: input,
       };
     }
 
     // Default to 'query' for question-like inputs
     if (input.match(/^(what|when|where|who|how|why)/i)) {
       return {
-                action: 'query',
+        action: "query",
-                target: extractedEntities.primary_target || 'system',
+        target: extractedEntities.primary_target || "system",
         confidence: 0.6,
         parameters: {},
-                raw_input: input
+        raw_input: input,
       };
     }
 
     // Fallback with low confidence
     return {
-            action: 'unknown',
+      action: "unknown",
-            target: extractedEntities.primary_target || 'system',
+      target: extractedEntities.primary_target || "system",
       confidence: 0.3,
       parameters: {},
-            raw_input: input
+      raw_input: input,
     };
   }
 }

src/ai/nlp/processor.ts

@@ -1,7 +1,7 @@
-import { AIIntent, AIContext, AIConfidence, AIError } from '../types/index.js';
+import { AIIntent, AIContext, AIConfidence, AIError } from "../types/index.js";
-import { EntityExtractor } from './entity-extractor.js';
+import { EntityExtractor } from "./entity-extractor.js";
-import { IntentClassifier } from './intent-classifier.js';
+import { IntentClassifier } from "./intent-classifier.js";
-import { ContextAnalyzer } from './context-analyzer.js';
+import { ContextAnalyzer } from "./context-analyzer.js";
 
 export class NLPProcessor {
   private entityExtractor: EntityExtractor;
@@ -16,7 +16,7 @@ export class NLPProcessor {
 
   async processCommand(
     input: string,
-        context: AIContext
+    context: AIContext,
   ): Promise<{
     intent: AIIntent;
     confidence: AIConfidence;
@@ -30,14 +30,21 @@ export class NLPProcessor {
       const intent = await this.intentClassifier.classify(input, entities);
 
       // Analyze context relevance
-            const contextRelevance = await this.contextAnalyzer.analyze(intent, context);
+      const contextRelevance = await this.contextAnalyzer.analyze(
+        intent,
+        context,
+      );
 
       // Calculate confidence scores
       const confidence: AIConfidence = {
-                overall: (intent.confidence + entities.confidence + contextRelevance.confidence) / 3,
+        overall:
+          (intent.confidence +
+            entities.confidence +
+            contextRelevance.confidence) /
+          3,
         intent: intent.confidence,
         entities: entities.confidence,
-                context: contextRelevance.confidence
+        context: contextRelevance.confidence,
       };
 
       // Create structured intent
@@ -47,41 +54,42 @@ export class NLPProcessor {
         parameters: {
           ...entities.parameters,
           ...intent.parameters,
-                    context_parameters: contextRelevance.relevant_params
+          context_parameters: contextRelevance.relevant_params,
         },
-                raw_input: input
+        raw_input: input,
       };
 
       return {
         intent: structuredIntent,
-                confidence
+        confidence,
       };
     } catch (error: unknown) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error occurred";
       return {
         intent: {
-                    action: 'error',
+          action: "error",
-                    target: 'system',
+          target: "system",
           parameters: {},
-                    raw_input: input
+          raw_input: input,
         },
         confidence: {
           overall: 0,
           intent: 0,
           entities: 0,
-                    context: 0
+          context: 0,
         },
         error: {
-                    code: 'NLP_PROCESSING_ERROR',
+          code: "NLP_PROCESSING_ERROR",
           message: errorMessage,
-                    suggestion: 'Please try rephrasing your command',
+          suggestion: "Please try rephrasing your command",
           recovery_options: [
-                        'Use simpler language',
+            "Use simpler language",
-                        'Break down the command into smaller parts',
+            "Break down the command into smaller parts",
-                        'Specify the target device explicitly'
+            "Specify the target device explicitly",
           ],
-                    context
+          context,
-                }
+        },
       };
     }
   }
@@ -89,7 +97,7 @@ export class NLPProcessor {
   async validateIntent(
     intent: AIIntent,
     confidence: AIConfidence,
-        threshold = 0.7
+    threshold = 0.7,
   ): Promise<boolean> {
     return (
       confidence.overall >= threshold &&
@@ -99,31 +107,28 @@ export class NLPProcessor {
     );
   }
 
-    async suggestCorrections(
+  async suggestCorrections(input: string, error: AIError): Promise<string[]> {
-        input: string,
-        error: AIError
-    ): Promise<string[]> {
     // Implement correction suggestions based on the error
     const suggestions: string[] = [];
 
-        if (error.code === 'ENTITY_NOT_FOUND') {
+    if (error.code === "ENTITY_NOT_FOUND") {
       suggestions.push(
-                'Try specifying the device name more clearly',
+        "Try specifying the device name more clearly",
-                'Use the exact device name from your Home Assistant setup'
+        "Use the exact device name from your Home Assistant setup",
       );
     }
 
-        if (error.code === 'AMBIGUOUS_INTENT') {
+    if (error.code === "AMBIGUOUS_INTENT") {
       suggestions.push(
-                'Please specify what you want to do with the device',
+        "Please specify what you want to do with the device",
-                'Use action words like "turn on", "set", "adjust"'
+        'Use action words like "turn on", "set", "adjust"',
       );
     }
 
-        if (error.code === 'CONTEXT_MISMATCH') {
+    if (error.code === "CONTEXT_MISMATCH") {
       suggestions.push(
-                'Specify the location if referring to a device',
+        "Specify the location if referring to a device",
-                'Clarify which device you mean in the current context'
+        "Clarify which device you mean in the current context",
       );
     }
 

src/ai/templates/prompt-templates.ts

@@ -1,4 +1,4 @@
-import { AIModel } from '../types/index.js';
+import { AIModel } from "../types/index.js";
 
 interface PromptTemplate {
   system: string;
@@ -33,13 +33,15 @@ Current context: {context}`,
         examples: [
           {
             user: "Turn on the living room lights",
-                        assistant: "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?"
+            assistant:
+              "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?",
           },
           {
             user: "Set the temperature to 72 degrees",
-                        assistant: "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target."
+            assistant:
-                    }
+              "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target.",
-                ]
+          },
+        ],
       },
       [AIModel.GPT4]: {
         system: `You are a home automation assistant powered by GPT-4.
@@ -52,13 +54,15 @@ Context: {context}`,
         examples: [
           {
             user: "Dim the bedroom lights to 50%",
-                        assistant: "Setting bedroom light brightness to 50%. The change has been applied successfully."
+            assistant:
+              "Setting bedroom light brightness to 50%. The change has been applied successfully.",
           },
           {
             user: "Start the evening routine",
-                        assistant: "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system."
+            assistant:
-                    }
+              "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system.",
-                ]
+          },
+        ],
       },
       [AIModel.CUSTOM]: {
         system: `Custom home automation assistant configuration.
@@ -73,14 +77,16 @@ Current context: {context}`,
         examples: [
           {
             user: "Make it cooler in here",
-                        assistant: "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F."
+            assistant:
+              "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F.",
           },
           {
             user: "Set up movie mode",
-                        assistant: "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system."
+            assistant:
-                    }
+              "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system.",
-                ]
+          },
-            }
+        ],
+      },
     };
   }
 
@@ -95,7 +101,7 @@ Current context: {context}`,
     // Replace variables in the prompt
     for (const [key, value] of Object.entries(variables)) {
       const placeholder = `{${key}}`;
-            if (typeof value === 'object') {
+      if (typeof value === "object") {
         prompt = prompt.replace(placeholder, JSON.stringify(value));
       } else {
         prompt = prompt.replace(placeholder, String(value));
@@ -115,7 +121,7 @@ Current context: {context}`,
 
   addExample(
     model: AIModel,
-        example: { user: string; assistant: string }
+    example: { user: string; assistant: string },
   ): void {
     this.templates[model].examples.push(example);
   }
@@ -124,10 +130,7 @@ Current context: {context}`,
     this.templates[model].system = newPrompt;
   }
 
-    createCustomTemplate(
+  createCustomTemplate(model: AIModel.CUSTOM, template: PromptTemplate): void {
-        model: AIModel.CUSTOM,
-        template: PromptTemplate
-    ): void {
     this.templates[model] = template;
   }
 }

src/ai/types/index.ts

@@ -1,10 +1,10 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // AI Model Types
 export enum AIModel {
-    CLAUDE = 'claude',
+  CLAUDE = "claude",
-    GPT4 = 'gpt4',
+  GPT4 = "gpt4",
-    CUSTOM = 'custom'
+  CUSTOM = "custom",
 }
 
 // AI Confidence Level
@@ -61,10 +61,13 @@ export interface AIRateLimit {
   requests_per_minute: number;
   requests_per_hour: number;
   concurrent_requests: number;
-    model_specific_limits: Record<AIModel, {
+  model_specific_limits: Record<
+    AIModel,
+    {
       requests_per_minute: number;
       requests_per_hour: number;
-    }>;
+    }
+  >;
 }
 
 // Zod Schemas
@@ -72,14 +75,14 @@ export const AIConfidenceSchema = z.object({
   overall: z.number().min(0).max(1),
   intent: z.number().min(0).max(1),
   entities: z.number().min(0).max(1),
-    context: z.number().min(0).max(1)
+  context: z.number().min(0).max(1),
 });
 
 export const AIIntentSchema = z.object({
   action: z.string(),
   target: z.string(),
   parameters: z.record(z.any()),
-    raw_input: z.string()
+  raw_input: z.string(),
 });
 
 export const AIContextSchema = z.object({
@@ -88,7 +91,7 @@ export const AIContextSchema = z.object({
   timestamp: z.string(),
   location: z.string(),
   previous_actions: z.array(AIIntentSchema),
-    environment_state: z.record(z.any())
+  environment_state: z.record(z.any()),
 });
 
 export const AIResponseSchema = z.object({
@@ -97,11 +100,11 @@ export const AIResponseSchema = z.object({
     success: z.boolean(),
     action_taken: z.string(),
     entities_affected: z.array(z.string()),
-        state_changes: z.record(z.any())
+    state_changes: z.record(z.any()),
   }),
   next_suggestions: z.array(z.string()),
   confidence: AIConfidenceSchema,
-    context: AIContextSchema
+  context: AIContextSchema,
 });
 
 export const AIErrorSchema = z.object({
@@ -109,15 +112,17 @@ export const AIErrorSchema = z.object({
   message: z.string(),
   suggestion: z.string(),
   recovery_options: z.array(z.string()),
-    context: AIContextSchema
+  context: AIContextSchema,
 });
 
 export const AIRateLimitSchema = z.object({
   requests_per_minute: z.number(),
   requests_per_hour: z.number(),
   concurrent_requests: z.number(),
-    model_specific_limits: z.record(z.object({
+  model_specific_limits: z.record(
+    z.object({
       requests_per_minute: z.number(),
-        requests_per_hour: z.number()
+      requests_per_hour: z.number(),
-    }))
+    }),
+  ),
 });

src/api/routes.ts

@@ -1,21 +1,21 @@
-import { Router } from 'express';
+import { Router } from "express";
-import { MCP_SCHEMA } from '../mcp/schema.js';
+import { MCP_SCHEMA } from "../mcp/schema.js";
-import { middleware } from '../middleware/index.js';
+import { middleware } from "../middleware/index.js";
-import { sseManager } from '../sse/index.js';
+import { sseManager } from "../sse/index.js";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
-import { TokenManager } from '../security/index.js';
+import { TokenManager } from "../security/index.js";
-import { tools } from '../tools/index.js';
+import { tools } from "../tools/index.js";
-import { Tool } from '../interfaces/index.js';
+import { Tool } from "../interfaces/index.js";
 
 const router = Router();
 
 // MCP schema endpoint - no auth required as it's just the schema
-router.get('/mcp', (_req, res) => {
+router.get("/mcp", (_req, res) => {
   res.json(MCP_SCHEMA);
 });
 
 // MCP execute endpoint - requires authentication
-router.post('/mcp/execute', middleware.authenticate, async (req, res) => {
+router.post("/mcp/execute", middleware.authenticate, async (req, res) => {
   try {
     const { tool: toolName, parameters } = req.body;
 
@@ -24,7 +24,7 @@ router.post('/mcp/execute', middleware.authenticate, async (req, res) => {
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: `Tool '${toolName}' not found`
+        message: `Tool '${toolName}' not found`,
       });
     }
 
@@ -34,67 +34,72 @@ router.post('/mcp/execute', middleware.authenticate, async (req, res) => {
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });
 
 // Health check endpoint
-router.get('/health', (_req, res) => {
+router.get("/health", (_req, res) => {
   res.json({
-        status: 'ok',
+    status: "ok",
     timestamp: new Date().toISOString(),
-        version: '0.1.0'
+    version: "0.1.0",
   });
 });
 
 // List devices endpoint
-router.get('/list_devices', middleware.authenticate, async (req, res) => {
+router.get("/list_devices", middleware.authenticate, async (req, res) => {
   try {
-        const tool = tools.find((t: Tool) => t.name === 'list_devices');
+    const tool = tools.find((t: Tool) => t.name === "list_devices");
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
       });
     }
 
-        const result = await tool.execute({ token: req.headers.authorization?.replace('Bearer ', '') });
+    const result = await tool.execute({
+      token: req.headers.authorization?.replace("Bearer ", ""),
+    });
     res.json(result);
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });
 
 // Device control endpoint
-router.post('/control', middleware.authenticate, async (req, res) => {
+router.post("/control", middleware.authenticate, async (req, res) => {
   try {
-        const tool = tools.find((t: Tool) => t.name === 'control');
+    const tool = tools.find((t: Tool) => t.name === "control");
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
       });
     }
 
     const result = await tool.execute({
       ...req.body,
-            token: req.headers.authorization?.replace('Bearer ', '')
+      token: req.headers.authorization?.replace("Bearer ", ""),
     });
     res.json(result);
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });
 
 // SSE endpoints
-router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
+router.get("/subscribe_events", middleware.wsRateLimiter, (req, res) => {
   try {
     // Get token from query parameter
     const token = req.query.token?.toString();
@@ -102,48 +107,54 @@ router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
     if (!token || !TokenManager.validateToken(token)) {
       return res.status(401).json({
         success: false,
-                message: 'Unauthorized - Invalid token'
+        message: "Unauthorized - Invalid token",
       });
     }
 
     // Set SSE headers
     res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
+      "Content-Type": "text/event-stream",
-            'Cache-Control': 'no-cache',
+      "Cache-Control": "no-cache",
-            'Connection': 'keep-alive',
+      Connection: "keep-alive",
-            'Access-Control-Allow-Origin': '*'
+      "Access-Control-Allow-Origin": "*",
     });
 
     // Send initial connection message
-        res.write(`data: ${JSON.stringify({
+    res.write(
-            type: 'connection',
+      `data: ${JSON.stringify({
-            status: 'connected',
+        type: "connection",
-            timestamp: new Date().toISOString()
+        status: "connected",
-        })}\n\n`);
+        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({
+      res.write(
-                type: 'error',
+        `data: ${JSON.stringify({
-                message: sseClient ? 'Authentication failed' : 'Maximum client limit reached',
+          type: "error",
-                timestamp: new Date().toISOString()
+          message: sseClient
-            })}\n\n`);
+            ? "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);
+    const events = req.query.events?.toString().split(",").filter(Boolean);
     if (events?.length) {
-            events.forEach(event => sseManager.subscribeToEvent(clientId, event));
+      events.forEach((event) => sseManager.subscribeToEvent(clientId, event));
     }
 
     // Subscribe to entity if specified
@@ -159,14 +170,14 @@ router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
     }
 
     // Handle client disconnect
-        req.on('close', () => {
+    req.on("close", () => {
       sseManager.removeClient(clientId);
     });
-
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });
@@ -185,19 +196,20 @@ router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
  *   - total_entities_tracked: Number of entities being tracked
  *   - subscriptions: Lists of entity, event, and domain subscriptions
  */
-router.get('/get_sse_stats', middleware.authenticate, (_req, res) => {
+router.get("/get_sse_stats", middleware.authenticate, (_req, res) => {
   try {
     const stats = sseManager.getStatistics();
     res.json({
       success: true,
       timestamp: new Date().toISOString(),
-            data: stats
+      data: stats,
     });
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred',
+      message:
-            timestamp: new Date().toISOString()
+        error instanceof Error ? error.message : "Unknown error occurred",
+      timestamp: new Date().toISOString(),
     });
   }
 });

src/commands.ts

@@ -0,0 +1,27 @@
+// Common commands that work with most entities
+export const commonCommands = ["turn_on", "turn_off", "toggle"] as const;
+
+// Commands specific to cover entities
+export const coverCommands = [
+  ...commonCommands,
+  "open",
+  "close",
+  "stop",
+  "set_position",
+  "set_tilt_position",
+] as const;
+
+// Commands specific to climate entities
+export const climateCommands = [
+  ...commonCommands,
+  "set_temperature",
+  "set_hvac_mode",
+  "set_fan_mode",
+  "set_humidity",
+] as const;
+
+// Types for command validation
+export type CommonCommand = (typeof commonCommands)[number];
+export type CoverCommand = (typeof coverCommands)[number];
+export type ClimateCommand = (typeof climateCommands)[number];
+export type Command = CommonCommand | CoverCommand | ClimateCommand;

src/config/__tests__/test.config.ts

@@ -1,19 +1,21 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // Test configuration schema
 const testConfigSchema = z.object({
   // Test Environment
   TEST_PORT: z.number().default(3001),
-    TEST_HOST: z.string().default('http://localhost'),
+  TEST_HOST: z.string().default("http://localhost"),
   TEST_WEBSOCKET_PORT: z.number().default(3002),
 
   // Mock Authentication
-    TEST_JWT_SECRET: z.string().default('test_jwt_secret_key_that_is_at_least_32_chars'),
+  TEST_JWT_SECRET: z
-    TEST_TOKEN: z.string().default('test_token_that_is_at_least_32_chars_long'),
+    .string()
-    TEST_INVALID_TOKEN: z.string().default('invalid_token'),
+    .default("test_jwt_secret_key_that_is_at_least_32_chars"),
+  TEST_TOKEN: z.string().default("test_token_that_is_at_least_32_chars_long"),
+  TEST_INVALID_TOKEN: z.string().default("invalid_token"),
 
   // Mock Client Settings
-    TEST_CLIENT_IP: z.string().default('127.0.0.1'),
+  TEST_CLIENT_IP: z.string().default("127.0.0.1"),
   TEST_MAX_CLIENTS: z.number().default(10),
   TEST_PING_INTERVAL: z.number().default(100),
   TEST_CLEANUP_INTERVAL: z.number().default(200),
@@ -25,104 +27,129 @@ const testConfigSchema = z.object({
   TEST_RATE_LIMIT_WEBSOCKET: z.number().default(1000),
 
   // Mock Events
-    TEST_EVENT_TYPES: z.array(z.string()).default([
+  TEST_EVENT_TYPES: z
-        'state_changed',
+    .array(z.string())
-        'automation_triggered',
+    .default([
-        'script_executed',
+      "state_changed",
-        'service_called'
+      "automation_triggered",
+      "script_executed",
+      "service_called",
     ]),
 
   // Mock Entities
-    TEST_ENTITIES: z.array(z.object({
+  TEST_ENTITIES: z
+    .array(
+      z.object({
         entity_id: z.string(),
         state: z.string(),
         attributes: z.record(z.any()),
         last_changed: z.string(),
-        last_updated: z.string()
+        last_updated: z.string(),
-    })).default([
+      }),
+    )
+    .default([
       {
-            entity_id: 'light.test_light',
+        entity_id: "light.test_light",
-            state: 'on',
+        state: "on",
         attributes: {
           brightness: 255,
-                color_temp: 400
+          color_temp: 400,
         },
         last_changed: new Date().toISOString(),
-            last_updated: new Date().toISOString()
+        last_updated: new Date().toISOString(),
       },
       {
-            entity_id: 'switch.test_switch',
+        entity_id: "switch.test_switch",
-            state: 'off',
+        state: "off",
         attributes: {},
         last_changed: new Date().toISOString(),
-            last_updated: new Date().toISOString()
+        last_updated: new Date().toISOString(),
-        }
+      },
     ]),
 
   // Mock Services
-    TEST_SERVICES: z.array(z.object({
+  TEST_SERVICES: z
+    .array(
+      z.object({
         domain: z.string(),
         service: z.string(),
-        data: z.record(z.any())
+        data: z.record(z.any()),
-    })).default([
+      }),
+    )
+    .default([
       {
-            domain: 'light',
+        domain: "light",
-            service: 'turn_on',
+        service: "turn_on",
         data: {
-                entity_id: 'light.test_light',
+          entity_id: "light.test_light",
-                brightness: 255
+          brightness: 255,
-            }
+        },
       },
       {
-            domain: 'switch',
+        domain: "switch",
-            service: 'turn_off',
+        service: "turn_off",
         data: {
-                entity_id: 'switch.test_switch'
+          entity_id: "switch.test_switch",
-            }
+        },
-        }
+      },
     ]),
 
   // Mock Error Scenarios
-    TEST_ERROR_SCENARIOS: z.array(z.object({
+  TEST_ERROR_SCENARIOS: z
+    .array(
+      z.object({
         type: z.string(),
         message: z.string(),
-        code: z.number()
+        code: z.number(),
-    })).default([
+      }),
+    )
+    .default([
       {
-            type: 'authentication_error',
+        type: "authentication_error",
-            message: 'Invalid token',
+        message: "Invalid token",
-            code: 401
+        code: 401,
       },
       {
-            type: 'rate_limit_error',
+        type: "rate_limit_error",
-            message: 'Too many requests',
+        message: "Too many requests",
-            code: 429
+        code: 429,
       },
       {
-            type: 'validation_error',
+        type: "validation_error",
-            message: 'Invalid request body',
+        message: "Invalid request body",
-            code: 400
+        code: 400,
-        }
+      },
-    ])
+    ]),
 });
 
 // Parse environment variables or use defaults
 const parseTestConfig = () => {
   const config = {
-        TEST_PORT: parseInt(process.env.TEST_PORT || '3001'),
+    TEST_PORT: parseInt(process.env.TEST_PORT || "3001"),
-        TEST_HOST: process.env.TEST_HOST || 'http://localhost',
+    TEST_HOST: process.env.TEST_HOST || "http://localhost",
-        TEST_WEBSOCKET_PORT: parseInt(process.env.TEST_WEBSOCKET_PORT || '3002'),
+    TEST_WEBSOCKET_PORT: parseInt(process.env.TEST_WEBSOCKET_PORT || "3002"),
-        TEST_JWT_SECRET: process.env.TEST_JWT_SECRET || 'test_jwt_secret_key_that_is_at_least_32_chars',
+    TEST_JWT_SECRET:
-        TEST_TOKEN: process.env.TEST_TOKEN || 'test_token_that_is_at_least_32_chars_long',
+      process.env.TEST_JWT_SECRET ||
-        TEST_INVALID_TOKEN: process.env.TEST_INVALID_TOKEN || 'invalid_token',
+      "test_jwt_secret_key_that_is_at_least_32_chars",
-        TEST_CLIENT_IP: process.env.TEST_CLIENT_IP || '127.0.0.1',
+    TEST_TOKEN:
-        TEST_MAX_CLIENTS: parseInt(process.env.TEST_MAX_CLIENTS || '10'),
+      process.env.TEST_TOKEN || "test_token_that_is_at_least_32_chars_long",
-        TEST_PING_INTERVAL: parseInt(process.env.TEST_PING_INTERVAL || '100'),
+    TEST_INVALID_TOKEN: process.env.TEST_INVALID_TOKEN || "invalid_token",
-        TEST_CLEANUP_INTERVAL: parseInt(process.env.TEST_CLEANUP_INTERVAL || '200'),
+    TEST_CLIENT_IP: process.env.TEST_CLIENT_IP || "127.0.0.1",
-        TEST_MAX_CONNECTION_AGE: parseInt(process.env.TEST_MAX_CONNECTION_AGE || '1000'),
+    TEST_MAX_CLIENTS: parseInt(process.env.TEST_MAX_CLIENTS || "10"),
-        TEST_RATE_LIMIT_WINDOW: parseInt(process.env.TEST_RATE_LIMIT_WINDOW || '60000'),
+    TEST_PING_INTERVAL: parseInt(process.env.TEST_PING_INTERVAL || "100"),
-        TEST_RATE_LIMIT_MAX_REQUESTS: parseInt(process.env.TEST_RATE_LIMIT_MAX_REQUESTS || '100'),
+    TEST_CLEANUP_INTERVAL: parseInt(process.env.TEST_CLEANUP_INTERVAL || "200"),
-        TEST_RATE_LIMIT_WEBSOCKET: parseInt(process.env.TEST_RATE_LIMIT_WEBSOCKET || '1000'),
+    TEST_MAX_CONNECTION_AGE: parseInt(
+      process.env.TEST_MAX_CONNECTION_AGE || "1000",
+    ),
+    TEST_RATE_LIMIT_WINDOW: parseInt(
+      process.env.TEST_RATE_LIMIT_WINDOW || "60000",
+    ),
+    TEST_RATE_LIMIT_MAX_REQUESTS: parseInt(
+      process.env.TEST_RATE_LIMIT_MAX_REQUESTS || "100",
+    ),
+    TEST_RATE_LIMIT_WEBSOCKET: parseInt(
+      process.env.TEST_RATE_LIMIT_WEBSOCKET || "1000",
+    ),
   };
 
   return testConfigSchema.parse(config);

src/config/app.config.ts

@@ -1,5 +1,6 @@
-import { config } from 'dotenv';
+import { config } from "dotenv";
-import { resolve } from 'path';
+import { resolve } from "path";
+import { z } from "zod";
 
 /**
  * Load environment variables based on NODE_ENV
@@ -7,11 +8,12 @@ import { resolve } from 'path';
  * Test: .env.test
  * Production: .env
  */
-const envFile = process.env.NODE_ENV === 'production'
+const envFile =
-    ? '.env'
+  process.env.NODE_ENV === "production"
-    : process.env.NODE_ENV === 'test'
+    ? ".env"
-        ? '.env.test'
+    : process.env.NODE_ENV === "test"
-        : '.env.development';
+      ? ".env.test"
+      : ".env.development";
 
 console.log(`Loading environment from ${envFile}`);
 config({ path: resolve(process.cwd(), envFile) });
@@ -20,59 +22,61 @@ config({ path: resolve(process.cwd(), envFile) });
  * Application configuration object
  * Contains all configuration settings for the application
  */
-export const APP_CONFIG = {
+export const AppConfigSchema = z.object({
   /** Server Configuration */
-    PORT: process.env.PORT || 3000,
+  PORT: z.number().default(4000),
-    NODE_ENV: process.env.NODE_ENV || 'development',
+  NODE_ENV: z
+    .enum(["development", "production", "test"])
+    .default("development"),
 
   /** Home Assistant Configuration */
-    HASS_HOST: process.env.HASS_HOST || 'http://192.168.178.63:8123',
+  HASS_HOST: z.string().default("http://192.168.178.63:8123"),
-    HASS_TOKEN: process.env.HASS_TOKEN,
+  HASS_TOKEN: z.string().optional(),
 
   /** Security Configuration */
-    JWT_SECRET: process.env.JWT_SECRET || 'your-secret-key',
+  JWT_SECRET: z.string().default("your-secret-key"),
-    RATE_LIMIT: {
+  RATE_LIMIT: z.object({
     /** Time window for rate limiting in milliseconds */
-        windowMs: 15 * 60 * 1000, // 15 minutes
+    windowMs: z.number().default(15 * 60 * 1000), // 15 minutes
     /** Maximum number of requests per window */
-        max: 100 // limit each IP to 100 requests per windowMs
+    max: z.number().default(100), // limit each IP to 100 requests per windowMs
-    },
+  }),
 
   /** Server-Sent Events Configuration */
-    SSE: {
+  SSE: z.object({
     /** Maximum number of concurrent SSE clients */
-        MAX_CLIENTS: 1000,
+    MAX_CLIENTS: z.number().default(1000),
     /** Ping interval in milliseconds to keep connections alive */
-        PING_INTERVAL: 30000 // 30 seconds
+    PING_INTERVAL: z.number().default(30000), // 30 seconds
-    },
+  }),
 
   /** Logging Configuration */
-    LOGGING: {
+  LOGGING: z.object({
     /** Log level (error, warn, info, http, debug) */
-        LEVEL: process.env.LOG_LEVEL || 'info',
+    LEVEL: z.enum(["error", "warn", "info", "debug", "trace"]).default("info"),
     /** Directory for log files */
-        DIR: process.env.LOG_DIR || 'logs',
+    DIR: z.string().default("logs"),
     /** Maximum log file size before rotation */
-        MAX_SIZE: process.env.LOG_MAX_SIZE || '20m',
+    MAX_SIZE: z.string().default("20m"),
     /** Maximum number of days to keep log files */
-        MAX_DAYS: process.env.LOG_MAX_DAYS || '14d',
+    MAX_DAYS: z.string().default("14d"),
     /** Whether to compress rotated logs */
-        COMPRESS: process.env.LOG_COMPRESS === 'true',
+    COMPRESS: z.boolean().default(false),
     /** Format for timestamps in logs */
-        TIMESTAMP_FORMAT: 'YYYY-MM-DD HH:mm:ss:ms',
+    TIMESTAMP_FORMAT: z.string().default("YYYY-MM-DD HH:mm:ss:ms"),
     /** Whether to include request logging */
-        LOG_REQUESTS: process.env.LOG_REQUESTS === 'true',
+    LOG_REQUESTS: z.boolean().default(false),
-    },
+  }),
 
   /** Application Version */
-    VERSION: '0.1.0'
+  VERSION: z.string().default("0.1.0"),
-} as const;
+});
 
 /** Type definition for the configuration object */
-export type AppConfig = typeof APP_CONFIG;
+export type AppConfig = z.infer<typeof AppConfigSchema>;
 
 /** Required environment variables that must be set */
-const requiredEnvVars = ['HASS_TOKEN'] as const;
+const requiredEnvVars = ["HASS_TOKEN"] as const;
 
 /**
  * Validate that all required environment variables are set
@@ -83,3 +87,30 @@ for (const envVar of requiredEnvVars) {
     throw new Error(`Missing required environment variable: ${envVar}`);
   }
 }
+
+// Load and validate configuration
+export const APP_CONFIG = AppConfigSchema.parse({
+  PORT: process.env.PORT || 4000,
+  NODE_ENV: process.env.NODE_ENV || "development",
+  HASS_HOST: process.env.HASS_HOST || "http://192.168.178.63:8123",
+  HASS_TOKEN: process.env.HASS_TOKEN,
+  JWT_SECRET: process.env.JWT_SECRET || "your-secret-key",
+  RATE_LIMIT: {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100, // limit each IP to 100 requests per windowMs
+  },
+  SSE: {
+    MAX_CLIENTS: 1000,
+    PING_INTERVAL: 30000, // 30 seconds
+  },
+  LOGGING: {
+    LEVEL: process.env.LOG_LEVEL || "info",
+    DIR: process.env.LOG_DIR || "logs",
+    MAX_SIZE: process.env.LOG_MAX_SIZE || "20m",
+    MAX_DAYS: process.env.LOG_MAX_DAYS || "14d",
+    COMPRESS: process.env.LOG_COMPRESS === "true",
+    TIMESTAMP_FORMAT: "YYYY-MM-DD HH:mm:ss:ms",
+    LOG_REQUESTS: process.env.LOG_REQUESTS === "true",
+  },
+  VERSION: "0.1.0",
+});

src/config/boilerplate.config.ts

@@ -0,0 +1,35 @@
+export const BOILERPLATE_CONFIG = {
+  configuration: {
+    LOG_LEVEL: {
+      type: "string" as const,
+      default: "debug",
+      description: "Logging level",
+      enum: ["error", "warn", "info", "debug", "trace"],
+    },
+    CACHE_DIRECTORY: {
+      type: "string" as const,
+      default: ".cache",
+      description: "Directory for cache files",
+    },
+    CONFIG_DIRECTORY: {
+      type: "string" as const,
+      default: ".config",
+      description: "Directory for configuration files",
+    },
+    DATA_DIRECTORY: {
+      type: "string" as const,
+      default: ".data",
+      description: "Directory for data files",
+    },
+  },
+  internal: {
+    boilerplate: {
+      configuration: {
+        LOG_LEVEL: "debug",
+        CACHE_DIRECTORY: ".cache",
+        CONFIG_DIRECTORY: ".config",
+        DATA_DIRECTORY: ".data",
+      },
+    },
+  },
+};

src/config/hass.config.ts

@@ -1,11 +1,50 @@
-import dotenv from 'dotenv';
+import { config } from "dotenv";
+import { resolve } from "path";
 
-// Load environment variables
+// Load environment variables based on NODE_ENV
-dotenv.config();
+const envFile =
+  process.env.NODE_ENV === "production"
+    ? ".env"
+    : process.env.NODE_ENV === "test"
+      ? ".env.test"
+      : ".env.development";
+
+config({ path: resolve(process.cwd(), envFile) });
 
 export const HASS_CONFIG = {
-    BASE_URL: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+  // Base configuration
-    TOKEN: process.env.HASS_TOKEN || '',
+  BASE_URL: process.env.HASS_HOST || "http://localhost:8123",
-    SOCKET_URL: process.env.HASS_SOCKET_URL || '',
+  TOKEN: process.env.HASS_TOKEN || "",
-    SOCKET_TOKEN: process.env.HASS_TOKEN || '',
+  SOCKET_URL: process.env.HASS_WS_URL || "ws://localhost:8123/api/websocket",
+  SOCKET_TOKEN: process.env.HASS_TOKEN || "",
+
+  // Boilerplate configuration
+  BOILERPLATE: {
+    CACHE_DIRECTORY: ".cache",
+    CONFIG_DIRECTORY: ".config",
+    DATA_DIRECTORY: ".data",
+    LOG_LEVEL: "debug",
+    ENVIRONMENT: process.env.NODE_ENV || "development",
+  },
+
+  // Application configuration
+  APP_NAME: "homeassistant-mcp",
+  APP_VERSION: "1.0.0",
+
+  // API configuration
+  API_VERSION: "1.0.0",
+  API_PREFIX: "/api",
+
+  // Security configuration
+  RATE_LIMIT: {
+    WINDOW_MS: 15 * 60 * 1000, // 15 minutes
+    MAX_REQUESTS: 100,
+  },
+
+  // WebSocket configuration
+  WS_CONFIG: {
+    AUTO_RECONNECT: true,
+    MAX_RECONNECT_ATTEMPTS: 3,
+    RECONNECT_DELAY: 1000,
+  },
 };

src/config/index.ts

@@ -1,76 +1,85 @@
-import { config } from 'dotenv';
+import { config } from "dotenv";
-import { resolve } from 'path';
+import { resolve } from "path";
 
 // Load environment variables based on NODE_ENV
-const envFile = process.env.NODE_ENV === 'production'
+const envFile =
-    ? '.env'
+  process.env.NODE_ENV === "production"
-    : process.env.NODE_ENV === 'test'
+    ? ".env"
-        ? '.env.test'
+    : process.env.NODE_ENV === "test"
-        : '.env.development';
+      ? ".env.test"
+      : ".env.development";
 
 console.log(`Loading environment from ${envFile}`);
 config({ path: resolve(process.cwd(), envFile) });
 
 // Home Assistant Configuration
 export const HASS_CONFIG = {
-    HOST: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+  HOST: process.env.HASS_HOST || "http://homeassistant.local:8123",
   TOKEN: process.env.HASS_TOKEN,
-    SOCKET_URL: process.env.HASS_SOCKET_URL || 'ws://homeassistant.local:8123/api/websocket',
+  SOCKET_URL:
-    BASE_URL: process.env.HASS_HOST || 'http://homeassistant.local:8123',
+    process.env.HASS_SOCKET_URL ||
-    SOCKET_TOKEN: process.env.HASS_TOKEN
+    "ws://homeassistant.local:8123/api/websocket",
+  BASE_URL: process.env.HASS_HOST || "http://homeassistant.local:8123",
+  SOCKET_TOKEN: process.env.HASS_TOKEN,
 };
 
 // Server Configuration
 export const SERVER_CONFIG = {
-    PORT: parseInt(process.env.PORT || '3000', 10),
+  PORT: parseInt(process.env.PORT || "3000", 10),
-    NODE_ENV: process.env.NODE_ENV || 'development',
+  NODE_ENV: process.env.NODE_ENV || "development",
-    DEBUG: process.env.DEBUG === 'true',
+  DEBUG: process.env.DEBUG === "true",
-    LOG_LEVEL: process.env.LOG_LEVEL || 'info'
+  LOG_LEVEL: process.env.LOG_LEVEL || "info",
 };
 
 // AI Configuration
 export const AI_CONFIG = {
-    PROCESSOR_TYPE: process.env.PROCESSOR_TYPE || 'claude',
+  PROCESSOR_TYPE: process.env.PROCESSOR_TYPE || "claude",
-    OPENAI_API_KEY: process.env.OPENAI_API_KEY
+  OPENAI_API_KEY: process.env.OPENAI_API_KEY,
 };
 
 // Rate Limiting Configuration
 export const RATE_LIMIT_CONFIG = {
-    REGULAR: parseInt(process.env.RATE_LIMIT_REGULAR || '100', 10),
+  REGULAR: parseInt(process.env.RATE_LIMIT_REGULAR || "100", 10),
-    WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || '1000', 10)
+  WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || "1000", 10),
 };
 
 // Security Configuration
 export const SECURITY_CONFIG = {
-    JWT_SECRET: process.env.JWT_SECRET || 'default_secret_key_change_in_production',
+  JWT_SECRET:
-    CORS_ORIGINS: (process.env.CORS_ORIGINS || 'http://localhost:3000,http://localhost:8123')
+    process.env.JWT_SECRET || "default_secret_key_change_in_production",
-        .split(',')
+  CORS_ORIGINS: (
-        .map(origin => origin.trim())
+    process.env.CORS_ORIGINS || "http://localhost:3000,http://localhost:8123"
+  )
+    .split(",")
+    .map((origin) => origin.trim()),
 };
 
 // Test Configuration
 export const TEST_CONFIG = {
-    HASS_HOST: process.env.TEST_HASS_HOST || 'http://localhost:8123',
+  HASS_HOST: process.env.TEST_HASS_HOST || "http://localhost:8123",
-    HASS_TOKEN: process.env.TEST_HASS_TOKEN || 'test_token',
+  HASS_TOKEN: process.env.TEST_HASS_TOKEN || "test_token",
-    HASS_SOCKET_URL: process.env.TEST_HASS_SOCKET_URL || 'ws://localhost:8123/api/websocket',
+  HASS_SOCKET_URL:
-    PORT: parseInt(process.env.TEST_PORT || '3001', 10)
+    process.env.TEST_HASS_SOCKET_URL || "ws://localhost:8123/api/websocket",
+  PORT: parseInt(process.env.TEST_PORT || "3001", 10),
 };
 
 // Mock Configuration (for testing)
 export const MOCK_CONFIG = {
-    SERVICES: process.env.MOCK_SERVICES === 'true',
+  SERVICES: process.env.MOCK_SERVICES === "true",
-    RESPONSES_DIR: process.env.MOCK_RESPONSES_DIR || '__tests__/mock-responses'
+  RESPONSES_DIR: process.env.MOCK_RESPONSES_DIR || "__tests__/mock-responses",
 };
 
 // Validate required configuration
 function validateConfig() {
   const missingVars: string[] = [];
 
-    if (!HASS_CONFIG.TOKEN) missingVars.push('HASS_TOKEN');
+  if (!HASS_CONFIG.TOKEN) missingVars.push("HASS_TOKEN");
-    if (!SECURITY_CONFIG.JWT_SECRET) missingVars.push('JWT_SECRET');
+  if (!SECURITY_CONFIG.JWT_SECRET) missingVars.push("JWT_SECRET");
 
   if (missingVars.length > 0) {
-        throw new Error(`Missing required environment variables: ${missingVars.join(', ')}`);
+    throw new Error(
+      `Missing required environment variables: ${missingVars.join(", ")}`,
+    );
   }
 }
 
@@ -85,5 +94,5 @@ export const AppConfig = {
   RATE_LIMIT: RATE_LIMIT_CONFIG,
   SECURITY: SECURITY_CONFIG,
   TEST: TEST_CONFIG,
-    MOCK: MOCK_CONFIG
+  MOCK: MOCK_CONFIG,
 };

src/config/security.config.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // Security configuration schema
 const securityConfigSchema = z.object({
@@ -6,7 +6,7 @@ const securityConfigSchema = z.object({
   JWT_SECRET: z.string().min(32),
   JWT_EXPIRY: z.number().default(24 * 60 * 60 * 1000), // 24 hours
   JWT_MAX_AGE: z.number().default(30 * 24 * 60 * 60 * 1000), // 30 days
-    JWT_ALGORITHM: z.enum(['HS256', 'HS384', 'HS512']).default('HS256'),
+  JWT_ALGORITHM: z.enum(["HS256", "HS384", "HS512"]).default("HS256"),
 
   // Rate Limiting
   RATE_LIMIT_WINDOW: z.number().default(15 * 60 * 1000), // 15 minutes
@@ -19,13 +19,15 @@ const securityConfigSchema = z.object({
   LOCKOUT_DURATION: z.number().default(15 * 60 * 1000), // 15 minutes
 
   // CORS Configuration
-    CORS_ORIGINS: z.array(z.string()).default(['http://localhost:3000', 'http://localhost:8123']),
+  CORS_ORIGINS: z
-    CORS_METHODS: z.array(z.string()).default(['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+    .array(z.string())
-    CORS_ALLOWED_HEADERS: z.array(z.string()).default([
+    .default(["http://localhost:3000", "http://localhost:8123"]),
-        'Content-Type',
+  CORS_METHODS: z
-        'Authorization',
+    .array(z.string())
-        'X-Requested-With'
+    .default(["GET", "POST", "PUT", "DELETE", "OPTIONS"]),
-    ]),
+  CORS_ALLOWED_HEADERS: z
+    .array(z.string())
+    .default(["Content-Type", "Authorization", "X-Requested-With"]),
   CORS_EXPOSED_HEADERS: z.array(z.string()).default([]),
   CORS_CREDENTIALS: z.boolean().default(true),
   CORS_MAX_AGE: z.number().default(24 * 60 * 60), // 24 hours
@@ -36,16 +38,16 @@ const securityConfigSchema = z.object({
   CSP_REPORT_URI: z.string().optional(),
 
   // SSL/TLS Configuration
-    REQUIRE_HTTPS: z.boolean().default(process.env.NODE_ENV === 'production'),
+  REQUIRE_HTTPS: z.boolean().default(process.env.NODE_ENV === "production"),
   HSTS_MAX_AGE: z.number().default(31536000), // 1 year
   HSTS_INCLUDE_SUBDOMAINS: z.boolean().default(true),
   HSTS_PRELOAD: z.boolean().default(true),
 
   // Cookie Security
   COOKIE_SECRET: z.string().min(32).optional(),
-    COOKIE_SECURE: z.boolean().default(process.env.NODE_ENV === 'production'),
+  COOKIE_SECURE: z.boolean().default(process.env.NODE_ENV === "production"),
   COOKIE_HTTP_ONLY: z.boolean().default(true),
-    COOKIE_SAME_SITE: z.enum(['Strict', 'Lax', 'None']).default('Strict'),
+  COOKIE_SAME_SITE: z.enum(["Strict", "Lax", "None"]).default("Strict"),
 
   // Request Limits
   MAX_REQUEST_SIZE: z.number().default(1024 * 1024), // 1MB
@@ -55,51 +57,66 @@ const securityConfigSchema = z.object({
 // Parse environment variables
 const parseEnvConfig = () => {
   const config = {
-        JWT_SECRET: process.env.JWT_SECRET || 'default_secret_key_change_in_production',
+    JWT_SECRET:
-        JWT_EXPIRY: parseInt(process.env.JWT_EXPIRY || '86400000'),
+      process.env.JWT_SECRET || "default_secret_key_change_in_production",
-        JWT_MAX_AGE: parseInt(process.env.JWT_MAX_AGE || '2592000000'),
+    JWT_EXPIRY: parseInt(process.env.JWT_EXPIRY || "86400000"),
-        JWT_ALGORITHM: process.env.JWT_ALGORITHM || 'HS256',
+    JWT_MAX_AGE: parseInt(process.env.JWT_MAX_AGE || "2592000000"),
+    JWT_ALGORITHM: process.env.JWT_ALGORITHM || "HS256",
 
-        RATE_LIMIT_WINDOW: parseInt(process.env.RATE_LIMIT_WINDOW || '900000'),
+    RATE_LIMIT_WINDOW: parseInt(process.env.RATE_LIMIT_WINDOW || "900000"),
-        RATE_LIMIT_MAX_REQUESTS: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100'),
+    RATE_LIMIT_MAX_REQUESTS: parseInt(
-        RATE_LIMIT_WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || '1000'),
+      process.env.RATE_LIMIT_MAX_REQUESTS || "100",
+    ),
+    RATE_LIMIT_WEBSOCKET: parseInt(process.env.RATE_LIMIT_WEBSOCKET || "1000"),
 
-        TOKEN_MIN_LENGTH: parseInt(process.env.TOKEN_MIN_LENGTH || '32'),
+    TOKEN_MIN_LENGTH: parseInt(process.env.TOKEN_MIN_LENGTH || "32"),
-        MAX_FAILED_ATTEMPTS: parseInt(process.env.MAX_FAILED_ATTEMPTS || '5'),
+    MAX_FAILED_ATTEMPTS: parseInt(process.env.MAX_FAILED_ATTEMPTS || "5"),
-        LOCKOUT_DURATION: parseInt(process.env.LOCKOUT_DURATION || '900000'),
+    LOCKOUT_DURATION: parseInt(process.env.LOCKOUT_DURATION || "900000"),
 
-        CORS_ORIGINS: (process.env.CORS_ORIGINS || 'http://localhost:3000,http://localhost:8123')
+    CORS_ORIGINS: (
-            .split(',')
+      process.env.CORS_ORIGINS || "http://localhost:3000,http://localhost:8123"
-            .map(origin => origin.trim()),
+    )
-        CORS_METHODS: (process.env.CORS_METHODS || 'GET,POST,PUT,DELETE,OPTIONS')
+      .split(",")
-            .split(',')
+      .map((origin) => origin.trim()),
-            .map(method => method.trim()),
+    CORS_METHODS: (process.env.CORS_METHODS || "GET,POST,PUT,DELETE,OPTIONS")
-        CORS_ALLOWED_HEADERS: (process.env.CORS_ALLOWED_HEADERS || 'Content-Type,Authorization,X-Requested-With')
+      .split(",")
-            .split(',')
+      .map((method) => method.trim()),
-            .map(header => header.trim()),
+    CORS_ALLOWED_HEADERS: (
-        CORS_EXPOSED_HEADERS: (process.env.CORS_EXPOSED_HEADERS || '')
+      process.env.CORS_ALLOWED_HEADERS ||
-            .split(',')
+      "Content-Type,Authorization,X-Requested-With"
+    )
+      .split(",")
+      .map((header) => header.trim()),
+    CORS_EXPOSED_HEADERS: (process.env.CORS_EXPOSED_HEADERS || "")
+      .split(",")
       .filter(Boolean)
-            .map(header => header.trim()),
+      .map((header) => header.trim()),
-        CORS_CREDENTIALS: process.env.CORS_CREDENTIALS !== 'false',
+    CORS_CREDENTIALS: process.env.CORS_CREDENTIALS !== "false",
-        CORS_MAX_AGE: parseInt(process.env.CORS_MAX_AGE || '86400'),
+    CORS_MAX_AGE: parseInt(process.env.CORS_MAX_AGE || "86400"),
 
-        CSP_ENABLED: process.env.CSP_ENABLED !== 'false',
+    CSP_ENABLED: process.env.CSP_ENABLED !== "false",
-        CSP_REPORT_ONLY: process.env.CSP_REPORT_ONLY === 'true',
+    CSP_REPORT_ONLY: process.env.CSP_REPORT_ONLY === "true",
     CSP_REPORT_URI: process.env.CSP_REPORT_URI,
 
-        REQUIRE_HTTPS: process.env.REQUIRE_HTTPS !== 'false' && process.env.NODE_ENV === 'production',
+    REQUIRE_HTTPS:
-        HSTS_MAX_AGE: parseInt(process.env.HSTS_MAX_AGE || '31536000'),
+      process.env.REQUIRE_HTTPS !== "false" &&
-        HSTS_INCLUDE_SUBDOMAINS: process.env.HSTS_INCLUDE_SUBDOMAINS !== 'false',
+      process.env.NODE_ENV === "production",
-        HSTS_PRELOAD: process.env.HSTS_PRELOAD !== 'false',
+    HSTS_MAX_AGE: parseInt(process.env.HSTS_MAX_AGE || "31536000"),
+    HSTS_INCLUDE_SUBDOMAINS: process.env.HSTS_INCLUDE_SUBDOMAINS !== "false",
+    HSTS_PRELOAD: process.env.HSTS_PRELOAD !== "false",
 
     COOKIE_SECRET: process.env.COOKIE_SECRET,
-        COOKIE_SECURE: process.env.COOKIE_SECURE !== 'false' && process.env.NODE_ENV === 'production',
+    COOKIE_SECURE:
-        COOKIE_HTTP_ONLY: process.env.COOKIE_HTTP_ONLY !== 'false',
+      process.env.COOKIE_SECURE !== "false" &&
-        COOKIE_SAME_SITE: (process.env.COOKIE_SAME_SITE || 'Strict') as 'Strict' | 'Lax' | 'None',
+      process.env.NODE_ENV === "production",
+    COOKIE_HTTP_ONLY: process.env.COOKIE_HTTP_ONLY !== "false",
+    COOKIE_SAME_SITE: (process.env.COOKIE_SAME_SITE || "Strict") as
+      | "Strict"
+      | "Lax"
+      | "None",
 
-        MAX_REQUEST_SIZE: parseInt(process.env.MAX_REQUEST_SIZE || '1048576'),
+    MAX_REQUEST_SIZE: parseInt(process.env.MAX_REQUEST_SIZE || "1048576"),
-        MAX_REQUEST_FIELDS: parseInt(process.env.MAX_REQUEST_FIELDS || '1000'),
+    MAX_REQUEST_FIELDS: parseInt(process.env.MAX_REQUEST_FIELDS || "1000"),
   };
 
   return securityConfigSchema.parse(config);

src/context/index.ts

@@ -1,14 +1,14 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 
 // Resource types
 export enum ResourceType {
-    DEVICE = 'device',
+  DEVICE = "device",
-    AREA = 'area',
+  AREA = "area",
-    USER = 'user',
+  USER = "user",
-    AUTOMATION = 'automation',
+  AUTOMATION = "automation",
-    SCENE = 'scene',
+  SCENE = "scene",
-    SCRIPT = 'script',
+  SCRIPT = "script",
-    GROUP = 'group'
+  GROUP = "group",
 }
 
 // Resource state interface
@@ -23,11 +23,11 @@ export interface ResourceState {
 
 // Resource relationship types
 export enum RelationType {
-    CONTAINS = 'contains',
+  CONTAINS = "contains",
-    CONTROLS = 'controls',
+  CONTROLS = "controls",
-    TRIGGERS = 'triggers',
+  TRIGGERS = "triggers",
-    DEPENDS_ON = 'depends_on',
+  DEPENDS_ON = "depends_on",
-    GROUPS = 'groups'
+  GROUPS = "groups",
 }
 
 // Resource relationship interface
@@ -52,7 +52,7 @@ export class ContextManager extends EventEmitter {
   // Resource management
   public addResource(resource: ResourceState): void {
     this.resources.set(resource.id, resource);
-        this.emit('resource_added', resource);
+    this.emit("resource_added", resource);
   }
 
   public updateResource(id: string, update: Partial<ResourceState>): void {
@@ -65,10 +65,10 @@ export class ContextManager extends EventEmitter {
       const updatedResource = {
         ...resource,
         ...update,
-                lastUpdated: Date.now()
+        lastUpdated: Date.now(),
       };
       this.resources.set(id, updatedResource);
-            this.emit('resource_updated', updatedResource);
+      this.emit("resource_updated", updatedResource);
     }
   }
 
@@ -78,25 +78,32 @@ export class ContextManager extends EventEmitter {
       this.resources.delete(id);
       // Remove related relationships
       this.relationships = this.relationships.filter(
-                rel => rel.sourceId !== id && rel.targetId !== id
+        (rel) => rel.sourceId !== id && rel.targetId !== id,
       );
-            this.emit('resource_removed', resource);
+      this.emit("resource_removed", resource);
     }
   }
 
   // Relationship management
   public addRelationship(relationship: ResourceRelationship): void {
     this.relationships.push(relationship);
-        this.emit('relationship_added', relationship);
+    this.emit("relationship_added", relationship);
   }
 
-    public removeRelationship(sourceId: string, targetId: string, type: RelationType): void {
+  public removeRelationship(
+    sourceId: string,
+    targetId: string,
+    type: RelationType,
+  ): void {
     const index = this.relationships.findIndex(
-            rel => rel.sourceId === sourceId && rel.targetId === targetId && rel.type === type
+      (rel) =>
+        rel.sourceId === sourceId &&
+        rel.targetId === targetId &&
+        rel.type === type,
     );
     if (index !== -1) {
       const removed = this.relationships.splice(index, 1)[0];
-            this.emit('relationship_removed', removed);
+      this.emit("relationship_removed", removed);
     }
   }
 
@@ -121,14 +128,14 @@ export class ContextManager extends EventEmitter {
 
   public getResourcesByType(type: ResourceType): ResourceState[] {
     return Array.from(this.resources.values()).filter(
-            resource => resource.type === type
+      (resource) => resource.type === type,
     );
   }
 
   public getRelatedResources(
     id: string,
     type?: RelationType,
-        depth: number = 1
+    depth: number = 1,
   ): ResourceState[] {
     const related = new Set<ResourceState>();
     const visited = new Set<string>();
@@ -138,12 +145,14 @@ export class ContextManager extends EventEmitter {
       visited.add(currentId);
 
       this.relationships
-                .filter(rel =>
+        .filter(
+          (rel) =>
             (rel.sourceId === currentId || rel.targetId === currentId) &&
-                    (!type || rel.type === type)
+            (!type || rel.type === type),
         )
-                .forEach(rel => {
+        .forEach((rel) => {
-                    const relatedId = rel.sourceId === currentId ? rel.targetId : rel.sourceId;
+          const relatedId =
+            rel.sourceId === currentId ? rel.targetId : rel.sourceId;
           const relatedResource = this.resources.get(relatedId);
           if (relatedResource) {
             related.add(relatedResource);
@@ -168,25 +177,29 @@ export class ContextManager extends EventEmitter {
     };
   } {
     const dependencies = this.relationships
-            .filter(rel => rel.sourceId === id && rel.type === RelationType.DEPENDS_ON)
+      .filter(
-            .map(rel => rel.targetId);
+        (rel) => rel.sourceId === id && rel.type === RelationType.DEPENDS_ON,
+      )
+      .map((rel) => rel.targetId);
 
     const dependents = this.relationships
-            .filter(rel => rel.targetId === id && rel.type === RelationType.DEPENDS_ON)
+      .filter(
-            .map(rel => rel.sourceId);
+        (rel) => rel.targetId === id && rel.type === RelationType.DEPENDS_ON,
+      )
+      .map((rel) => rel.sourceId);
 
     const groups = this.relationships
-            .filter(rel => rel.targetId === id && rel.type === RelationType.GROUPS)
+      .filter((rel) => rel.targetId === id && rel.type === RelationType.GROUPS)
-            .map(rel => rel.sourceId);
+      .map((rel) => rel.sourceId);
 
     const usage = {
       triggerCount: this.relationships.filter(
-                rel => rel.sourceId === id && rel.type === RelationType.TRIGGERS
+        (rel) => rel.sourceId === id && rel.type === RelationType.TRIGGERS,
       ).length,
       controlCount: this.relationships.filter(
-                rel => rel.sourceId === id && rel.type === RelationType.CONTROLS
+        (rel) => rel.sourceId === id && rel.type === RelationType.CONTROLS,
       ).length,
-            groupCount: groups.length
+      groupCount: groups.length,
     };
 
     return { dependencies, dependents, groups, usage };
@@ -195,7 +208,7 @@ export class ContextManager extends EventEmitter {
   // Event subscriptions
   public subscribeToResource(
     id: string,
-        callback: (state: ResourceState) => void
+    callback: (state: ResourceState) => void,
   ): () => void {
     const handler = (resource: ResourceState) => {
       if (resource.id === id) {
@@ -203,13 +216,13 @@ export class ContextManager extends EventEmitter {
       }
     };
 
-        this.on('resource_updated', handler);
+    this.on("resource_updated", handler);
-        return () => this.off('resource_updated', handler);
+    return () => this.off("resource_updated", handler);
   }
 
   public subscribeToType(
     type: ResourceType,
-        callback: (state: ResourceState) => void
+    callback: (state: ResourceState) => void,
   ): () => void {
     const handler = (resource: ResourceState) => {
       if (resource.type === type) {
@@ -217,8 +230,8 @@ export class ContextManager extends EventEmitter {
       }
     };
 
-        this.on('resource_updated', handler);
+    this.on("resource_updated", handler);
-        return () => this.off('resource_updated', handler);
+    return () => this.off("resource_updated", handler);
   }
 }
 

src/hass/index.ts

@@ -1,429 +1,64 @@
-import { CreateApplication, TServiceParams, ServiceFunction, AlsExtension, GetApisResult, ILogger, InternalDefinition, TContext, TInjectedConfig, TLifecycleBase, TScheduler } from "@digital-alchemy/core";
+import { CreateApplication } from "@digital-alchemy/core";
-import { Area, Backup, CallProxy, Configure, Device, EntityManager, EventsService, FetchAPI, FetchInternals, Floor, IDByExtension, Label, LIB_HASS, ReferenceService, Registry, WebsocketAPI, Zone } from "@digital-alchemy/hass";
+import { LIB_HASS } from "@digital-alchemy/hass";
-import { DomainSchema } from "../schemas.js";
-import { HASS_CONFIG } from "../config/hass.config.js";
-import { WebSocket } from 'ws';
-import { EventEmitter } from 'events';
-import * as HomeAssistant from '../types/hass.js';
 
-type Environments = "development" | "production" | "test";
+// Create the application following the documentation example
-
+const app = CreateApplication({
-// Define the type for Home Assistant services
+  libraries: [LIB_HASS],
-type HassServiceMethod = (data: Record<string, unknown>) => Promise<void>;
+  name: "home_automation",
-
-type HassServices = {
-  [K in keyof typeof DomainSchema.Values]: {
-    [service: string]: HassServiceMethod;
-  };
-};
-
-// Define the type for Home Assistant instance
-interface HassInstance extends TServiceParams {
-  baseUrl: string;
-  token: string;
-  wsClient: HassWebSocketClient | undefined;
-  services: HassServices;
-  als: AlsExtension;
-  context: TContext;
-  event: EventEmitter<[never]>;
-  internal: InternalDefinition;
-  lifecycle: TLifecycleBase;
-  logger: ILogger;
-  scheduler: TScheduler;
-  config: TInjectedConfig;
-  params: TServiceParams;
-  hass: GetApisResult<{
-    area: typeof Area;
-    backup: typeof Backup;
-    call: typeof CallProxy;
-    configure: typeof Configure;
-    device: typeof Device;
-    entity: typeof EntityManager;
-    events: typeof EventsService;
-    fetch: typeof FetchAPI;
-    floor: typeof Floor;
-    idBy: typeof IDByExtension;
-    internals: typeof FetchInternals;
-    label: typeof Label;
-    refBy: typeof ReferenceService;
-    registry: typeof Registry;
-    socket: typeof WebsocketAPI;
-    zone: typeof Zone;
-  }>;
-}
-
-// Configuration type for application with more specific constraints
-type ApplicationConfiguration = {
-  NODE_ENV: ServiceFunction<Environments>;
-};
-
-// Strict configuration type for Home Assistant
-type HassConfiguration = {
-  BASE_URL: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  TOKEN: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  SOCKET_URL: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-  SOCKET_TOKEN: {
-    type: "string";
-    description: string;
-    required: true;
-    default: string;
-  };
-};
-
-// application
-const MY_APP = CreateApplication<ApplicationConfiguration, {}>({
-  configuration: {
-    NODE_ENV: {
-      type: "string",
-      default: "development",
-      enum: ["development", "production", "test"],
-      description: "Code runner addon can set with it's own NODE_ENV",
-    },
-  },
-  services: {
-    NODE_ENV: () => {
-      // Directly return the default value or use process.env
-      return (process.env.NODE_ENV as Environments) || "development";
-    }
-  },
-  libraries: [
-    {
-      ...LIB_HASS,
   configuration: {
+    hass: {
       BASE_URL: {
-          type: "string",
+        type: "string" as const,
-          description: "Home Assistant base URL",
+        default: process.env.HASS_HOST || "http://localhost:8123",
-          required: true,
+        description: "Home Assistant URL",
-          default: HASS_CONFIG.BASE_URL
       },
       TOKEN: {
-          type: "string",
+        type: "string" as const,
+        default: process.env.HASS_TOKEN || "",
         description: "Home Assistant long-lived access token",
-          required: true,
-          default: HASS_CONFIG.TOKEN
       },
-        SOCKET_URL: {
-          type: "string",
-          description: "Home Assistant WebSocket URL",
-          required: true,
-          default: HASS_CONFIG.SOCKET_URL
     },
-        SOCKET_TOKEN: {
+  },
-          type: "string",
-          description: "Home Assistant WebSocket token",
-          required: true,
-          default: HASS_CONFIG.SOCKET_TOKEN
-        }
-      }
-    }
-  ],
-  name: 'hass' as const
 });
 
-export interface HassConfig {
+let instance: Awaited<ReturnType<typeof app.bootstrap>>;
-  host: string;
-  token: string;
-}
 
-const CONFIG: Record<string, HassConfig> = {
+export async function get_hass() {
-  development: {
+  if (!instance) {
-    host: process.env.HASS_HOST || 'http://localhost:8123',
-    token: process.env.HASS_TOKEN || ''
-  },
-  production: {
-    host: process.env.HASS_HOST || '',
-    token: process.env.HASS_TOKEN || ''
-  },
-  test: {
-    host: 'http://localhost:8123',
-    token: 'test_token'
-  }
-};
-
-export class HassWebSocketClient extends EventEmitter {
-  private ws: WebSocket | null = null;
-  private messageId = 1;
-  private subscriptions = new Map<number, (data: any) => void>();
-  private reconnectAttempts = 0;
-  private options: {
-    autoReconnect: boolean;
-    maxReconnectAttempts: number;
-    reconnectDelay: number;
-  };
-
-  constructor(
-    private url: string,
-    private token: string,
-    options: Partial<typeof HassWebSocketClient.prototype.options> = {}
-  ) {
-    super();
-    this.options = {
-      autoReconnect: true,
-      maxReconnectAttempts: 3,
-      reconnectDelay: 1000,
-      ...options
-    };
-  }
-
-  async connect(): Promise<void> {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.url);
-
-      this.ws.on('open', () => {
-        this.emit('open');
-        const authMessage: HomeAssistant.AuthMessage = {
-          type: 'auth',
-          access_token: this.token
-        };
-        this.ws?.send(JSON.stringify(authMessage));
-      });
-
-      this.ws.on('message', (data: string) => {
     try {
-          const message = JSON.parse(data);
+      instance = await app.bootstrap();
-          this.handleMessage(message);
     } catch (error) {
-          this.emit('error', new Error('Failed to parse message'));
+      console.error("Failed to initialize Home Assistant:", error);
+      throw error;
     }
-      });
-
-      this.ws.on('close', () => {
-        this.emit('disconnected');
-        if (this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
-          setTimeout(() => {
-            this.reconnectAttempts++;
-            this.connect();
-          }, this.options.reconnectDelay);
   }
-      });
+  return instance;
-
-      this.ws.on('error', (error) => {
-        this.emit('error', error);
-        reject(error);
-      });
-    });
 }
 
-  private handleMessage(message: any): void {
+// Helper function to call Home Assistant services
-    switch (message.type) {
+export async function call_service(
-      case 'auth_ok':
+  domain: string,
-        this.emit('auth_ok');
+  service: string,
-        break;
+  data: Record<string, any>,
-      case 'auth_invalid':
+) {
-        this.emit('auth_invalid');
+  const hass = await get_hass();
-        break;
+  return hass.hass.internals.callService(domain, service, data);
-      case 'result':
-        // Handle command results
-        break;
-      case 'event':
-        if (message.event) {
-          this.emit('event', message.event);
-          const subscription = this.subscriptions.get(message.id);
-          if (subscription) {
-            subscription(message.event.data);
-          }
-        }
-        break;
-      default:
-        this.emit('error', new Error(`Unknown message type: ${message.type}`));
-    }
 }
 
-  async subscribeEvents(callback: (data: any) => void, eventType?: string): Promise<number> {
+// Helper function to list devices
-    const id = this.messageId++;
+export async function list_devices() {
-    const message = {
+  const hass = await get_hass();
-      id,
+  return hass.hass.device.list();
-      type: 'subscribe_events',
-      event_type: eventType
-    };
-
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new Error('WebSocket not connected'));
-        return;
 }
 
-      this.subscriptions.set(id, callback);
+// Helper function to get entity states
-      this.ws.send(JSON.stringify(message));
+export async function get_states() {
-      resolve(id);
+  const hass = await get_hass();
-    });
+  return hass.hass.internals.getStates();
 }
 
-  async unsubscribeEvents(subscriptionId: number): Promise<void> {
+// Helper function to get a specific entity state
-    const message = {
+export async function get_state(entity_id: string) {
-      id: this.messageId++,
+  const hass = await get_hass();
-      type: 'unsubscribe_events',
+  return hass.hass.internals.getState(entity_id);
-      subscription: subscriptionId
-    };
-
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new Error('WebSocket not connected'));
-        return;
-      }
-
-      this.ws.send(JSON.stringify(message));
-      this.subscriptions.delete(subscriptionId);
-      resolve();
-    });
-  }
-
-  disconnect(): void {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-}
-
-export class HassInstanceImpl implements HassInstance {
-  public readonly baseUrl: string;
-  public readonly token: string;
-  public wsClient: HassWebSocketClient | undefined;
-
-  public services!: HassServices;
-  public als!: AlsExtension;
-  public context!: TContext;
-  public event!: EventEmitter<[never]>;
-  public internal!: InternalDefinition;
-  public lifecycle!: TLifecycleBase;
-  public logger!: ILogger;
-  public scheduler!: TScheduler;
-  public config!: TInjectedConfig;
-  public params!: TServiceParams;
-  public hass!: GetApisResult<{
-    area: typeof Area;
-    backup: typeof Backup;
-    call: typeof CallProxy;
-    configure: typeof Configure;
-    device: typeof Device;
-    entity: typeof EntityManager;
-    events: typeof EventsService;
-    fetch: typeof FetchAPI;
-    floor: typeof Floor;
-    idBy: typeof IDByExtension;
-    internals: typeof FetchInternals;
-    label: typeof Label;
-    refBy: typeof ReferenceService;
-    registry: typeof Registry;
-    socket: typeof WebsocketAPI;
-    zone: typeof Zone;
-  }>;
-
-  constructor(baseUrl: string, token: string) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-    this.initialize();
-  }
-
-  private initialize() {
-    // Initialize all required properties with proper type instantiation
-    this.services = {} as HassServices;
-    this.als = {} as AlsExtension;
-    this.context = {} as TContext;
-    this.event = new EventEmitter();
-    this.internal = {} as InternalDefinition;
-    this.lifecycle = {} as TLifecycleBase;
-    this.logger = {} as ILogger;
-    this.scheduler = {} as TScheduler;
-    this.config = {} as TInjectedConfig;
-    this.params = {} as TServiceParams;
-    this.hass = {} as GetApisResult<any>;
-  }
-
-  async fetchStates(): Promise<HomeAssistant.Entity[]> {
-    const response = await fetch(`${this.baseUrl}/api/states`, {
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch states: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data as HomeAssistant.Entity[];
-  }
-
-  async fetchState(entityId: string): Promise<HomeAssistant.Entity> {
-    const response = await fetch(`${this.baseUrl}/api/states/${entityId}`, {
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch state: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data as HomeAssistant.Entity;
-  }
-
-  async callService(domain: string, service: string, data: Record<string, any>): Promise<void> {
-    const response = await fetch(`${this.baseUrl}/api/services/${domain}/${service}`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(data),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Service call failed: ${response.statusText}`);
-    }
-  }
-
-  async subscribeEvents(callback: (event: HomeAssistant.Event) => void, eventType?: string): Promise<number> {
-    if (!this.wsClient) {
-      this.wsClient = new HassWebSocketClient(
-        this.baseUrl.replace(/^http/, 'ws') + '/api/websocket',
-        this.token
-      );
-      await this.wsClient.connect();
-    }
-
-    return this.wsClient.subscribeEvents(callback, eventType);
-  }
-
-  async unsubscribeEvents(subscriptionId: number): Promise<void> {
-    if (this.wsClient) {
-      await this.wsClient.unsubscribeEvents(subscriptionId);
-    }
-  }
-}
-
-let hassInstance: HassInstance | null = null;
-
-export async function get_hass(): Promise<HassInstance> {
-  if (!hassInstance) {
-    // Safely get configuration keys, providing an empty object as fallback
-    const _sortedConfigKeys = Object.keys(MY_APP.configuration ?? {}).sort();
-    const instance = await MY_APP.bootstrap();
-    hassInstance = instance as HassInstance;
-  }
-  return hassInstance;
 }

src/health-check.ts

@@ -1,14 +1,14 @@
 const check = async () => {
   try {
-        const response = await fetch('http://localhost:3000/health');
+    const response = await fetch("http://localhost:3000/health");
     if (!response.ok) {
-            console.error('Health check failed:', response.status);
+      console.error("Health check failed:", response.status);
       process.exit(1);
     }
-        console.log('Health check passed');
+    console.log("Health check passed");
     process.exit(0);
   } catch (error) {
-        console.error('Health check failed:', error);
+    console.error("Health check failed:", error);
     process.exit(1);
   }
 };

src/interfaces/hass.ts

@@ -29,7 +29,10 @@ export interface HassInstance {
   states: HassStates;
   services: HassServices;
   connection: HassConnection;
-    subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
+  subscribeEvents: (
+    callback: (event: HassEvent) => void,
+    eventType?: string,
+  ) => Promise<number>;
   unsubscribeEvents: (subscription: number) => void;
 }
 
@@ -41,12 +44,19 @@ export interface HassStates {
 
 export interface HassServices {
   get: () => Promise<Record<string, Record<string, HassService>>>;
-    call: (domain: string, service: string, serviceData?: Record<string, any>) => Promise<void>;
+  call: (
+    domain: string,
+    service: string,
+    serviceData?: Record<string, any>,
+  ) => Promise<void>;
 }
 
 export interface HassConnection {
   socket: WebSocket;
-    subscribeEvents: (callback: (event: HassEvent) => void, eventType?: string) => Promise<number>;
+  subscribeEvents: (
+    callback: (event: HassEvent) => void,
+    eventType?: string,
+  ) => Promise<number>;
   unsubscribeEvents: (subscription: number) => void;
 }
 
@@ -58,13 +68,16 @@ export interface HassService {
       domain: string[];
     };
   };
-    fields: Record<string, {
+  fields: Record<
+    string,
+    {
       name: string;
       description: string;
       required?: boolean;
       example?: any;
       selector?: any;
-    }>;
+    }
+  >;
 }
 
 export interface HassEvent {

src/interfaces/index.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 // Tool interfaces
 export interface Tool {
@@ -39,8 +39,8 @@ export type {
   HassService,
   HassEvent,
   HassEntity,
-    HassState
+  HassState,
-} from './hass.js';
+} from "./hass.js";
 
 // Home Assistant interfaces
 export interface HassAddon {
@@ -92,7 +92,7 @@ export interface HacsResponse {
 export interface AutomationConfig {
   alias: string;
   description?: string;
-    mode?: 'single' | 'parallel' | 'queued' | 'restart';
+  mode?: "single" | "parallel" | "queued" | "restart";
   trigger: any[];
   condition?: any[];
   action: any[];
@@ -125,7 +125,7 @@ export interface HistoryParams {
 
 // Scene interfaces
 export interface SceneParams {
-    action: 'list' | 'activate';
+  action: "list" | "activate";
   scene_id?: string;
 }
 
@@ -139,30 +139,43 @@ export interface NotifyParams {
 
 // Automation parameter interfaces
 export interface AutomationParams {
-    action: 'list' | 'toggle' | 'trigger';
+  action: "list" | "toggle" | "trigger";
   automation_id?: string;
 }
 
 export interface AddonParams {
-    action: 'list' | 'info' | 'install' | 'uninstall' | 'start' | 'stop' | 'restart';
+  action:
+    | "list"
+    | "info"
+    | "install"
+    | "uninstall"
+    | "start"
+    | "stop"
+    | "restart";
   slug?: string;
   version?: string;
 }
 
 export interface PackageParams {
-    action: 'list' | 'install' | 'uninstall' | 'update';
+  action: "list" | "install" | "uninstall" | "update";
-    category: 'integration' | 'plugin' | 'theme' | 'python_script' | 'appdaemon' | 'netdaemon';
+  category:
+    | "integration"
+    | "plugin"
+    | "theme"
+    | "python_script"
+    | "appdaemon"
+    | "netdaemon";
   repository?: string;
   version?: string;
 }
 
 export interface AutomationConfigParams {
-    action: 'create' | 'update' | 'delete' | 'duplicate';
+  action: "create" | "update" | "delete" | "duplicate";
   automation_id?: string;
   config?: {
     alias: string;
     description?: string;
-        mode?: 'single' | 'parallel' | 'queued' | 'restart';
+    mode?: "single" | "parallel" | "queued" | "restart";
     trigger: any[];
     condition?: any[];
     action: any[];

src/mcp/litemcp.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 
 export class LiteMCP extends EventEmitter {
   private static instance: LiteMCP;
@@ -19,7 +19,7 @@ export class LiteMCP extends EventEmitter {
     // Store configuration
     this.config = {
       ...this.defaultConfig,
-            ...config
+      ...config,
     };
   }
 
@@ -27,31 +27,37 @@ export class LiteMCP extends EventEmitter {
   private defaultConfig = {
     maxRetries: 3,
     retryDelay: 1000,
-        timeout: 5000
+    timeout: 5000,
   };
 
-    public async execute(command: string, params: Record<string, any> = {}): Promise<any> {
+  public async execute(
+    command: string,
+    params: Record<string, any> = {},
+  ): Promise<any> {
     try {
       // Emit command execution event
-            this.emit('command', { command, params });
+      this.emit("command", { command, params });
 
       // Execute command logic here
       const result = await this.processCommand(command, params);
 
       // Emit success event
-            this.emit('success', { command, params, result });
+      this.emit("success", { command, params, result });
 
       return result;
     } catch (error) {
       // Emit error event
-            this.emit('error', { command, params, error });
+      this.emit("error", { command, params, error });
       throw error;
     }
   }
 
-    private async processCommand(command: string, params: Record<string, any>): Promise<any> {
+  private async processCommand(
+    command: string,
+    params: Record<string, any>,
+  ): Promise<any> {
     // Command processing logic
-        return { command, params, status: 'processed' };
+    return { command, params, status: "processed" };
   }
 
   public async shutdown(): Promise<void> {

src/mcp/schema.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { DomainSchema } from '../schemas.js';
+import { DomainSchema } from "../schemas.js";
 
 export const MCP_SCHEMA = {
   tools: [
@@ -24,14 +24,14 @@ export const MCP_SCHEMA = {
               "vacuum",
               "scene",
               "script",
-                            "camera"
+              "camera",
-                        ]
+            ],
           },
           area: { type: "string" },
-                    floor: { type: "string" }
+          floor: { type: "string" },
+        },
+        required: [],
       },
-                required: []
-            }
     },
     {
       name: "control",
@@ -53,8 +53,8 @@ export const MCP_SCHEMA = {
               "set_temperature",
               "set_hvac_mode",
               "set_fan_mode",
-                            "set_humidity"
+              "set_humidity",
-                        ]
+            ],
           },
           entity_id: { type: "string" },
           state: { type: "string" },
@@ -64,7 +64,7 @@ export const MCP_SCHEMA = {
             type: "array",
             items: { type: "number" },
             minItems: 3,
-                        maxItems: 3
+            maxItems: 3,
           },
           position: { type: "number" },
           tilt_position: { type: "number" },
@@ -73,10 +73,10 @@ export const MCP_SCHEMA = {
           target_temp_low: { type: "number" },
           hvac_mode: { type: "string" },
           fan_mode: { type: "string" },
-                    humidity: { type: "number" }
+          humidity: { type: "number" },
+        },
+        required: ["command", "entity_id"],
       },
-                required: ["command", "entity_id"]
-            }
     },
     {
       name: "subscribe_events",
@@ -86,13 +86,13 @@ export const MCP_SCHEMA = {
         properties: {
           events: {
             type: "array",
-                        items: { type: "string" }
+            items: { type: "string" },
           },
           entity_id: { type: "string" },
-                    domain: { type: "string" }
+          domain: { type: "string" },
+        },
+        required: [],
       },
-                required: []
-            }
     },
     {
       name: "get_sse_stats",
@@ -100,8 +100,8 @@ export const MCP_SCHEMA = {
       parameters: {
         type: "object",
         properties: {},
-                required: []
+        required: [],
-            }
+      },
     },
     {
       name: "automation_config",
@@ -111,7 +111,7 @@ export const MCP_SCHEMA = {
         properties: {
           action: {
             type: "string",
-                        enum: ["list", "toggle", "trigger", "create", "update", "delete"]
+            enum: ["list", "toggle", "trigger", "create", "update", "delete"],
           },
           automation_id: { type: "string" },
           config: {
@@ -121,17 +121,17 @@ export const MCP_SCHEMA = {
               description: { type: "string" },
               mode: {
                 type: "string",
-                                enum: ["single", "parallel", "queued", "restart"]
+                enum: ["single", "parallel", "queued", "restart"],
               },
               trigger: { type: "array" },
               condition: { type: "array" },
-                            action: { type: "array" }
+              action: { type: "array" },
             },
-                        required: ["alias", "trigger", "action"]
+            required: ["alias", "trigger", "action"],
-                    }
+          },
+        },
+        required: ["action"],
       },
-                required: ["action"]
-            }
     },
     {
       name: "addon_management",
@@ -141,13 +141,21 @@ export const MCP_SCHEMA = {
         properties: {
           action: {
             type: "string",
-                        enum: ["list", "info", "install", "uninstall", "start", "stop", "restart"]
+            enum: [
+              "list",
+              "info",
+              "install",
+              "uninstall",
+              "start",
+              "stop",
+              "restart",
+            ],
           },
           slug: { type: "string" },
-                    version: { type: "string" }
+          version: { type: "string" },
+        },
+        required: ["action"],
       },
-                required: ["action"]
-            }
     },
     {
       name: "package_management",
@@ -157,17 +165,24 @@ export const MCP_SCHEMA = {
         properties: {
           action: {
             type: "string",
-                        enum: ["list", "install", "uninstall", "update"]
+            enum: ["list", "install", "uninstall", "update"],
           },
           category: {
             type: "string",
-                        enum: ["integration", "plugin", "theme", "python_script", "appdaemon", "netdaemon"]
+            enum: [
+              "integration",
+              "plugin",
+              "theme",
+              "python_script",
+              "appdaemon",
+              "netdaemon",
+            ],
           },
           repository: { type: "string" },
-                    version: { type: "string" }
+          version: { type: "string" },
+        },
+        required: ["action", "category"],
       },
-                required: ["action", "category"]
-            }
     },
     {
       name: "scene_control",
@@ -177,12 +192,12 @@ export const MCP_SCHEMA = {
         properties: {
           action: {
             type: "string",
-                        enum: ["list", "activate"]
+            enum: ["list", "activate"],
           },
-                    scene_id: { type: "string" }
+          scene_id: { type: "string" },
+        },
+        required: ["action"],
       },
-                required: ["action"]
-            }
     },
     {
       name: "notify",
@@ -195,11 +210,11 @@ export const MCP_SCHEMA = {
           target: { type: "string" },
           data: {
             type: "object",
-                        additionalProperties: true
+            additionalProperties: true,
-                    }
+          },
+        },
+        required: ["message"],
       },
-                required: ["message"]
-            }
     },
     {
       name: "history",
@@ -211,147 +226,173 @@ export const MCP_SCHEMA = {
           start_time: { type: "string" },
           end_time: { type: "string" },
           minimal_response: { type: "boolean" },
-                    significant_changes_only: { type: "boolean" }
+          significant_changes_only: { type: "boolean" },
+        },
+        required: ["entity_id"],
+      },
     },
-                required: ["entity_id"]
-            }
-        }
   ],
   prompts: [
     {
       name: "claude",
-            description: "Claude-specific prompt template for home automation control",
+      description:
+        "Claude-specific prompt template for home automation control",
       template: {
-                system: "You are Claude, an AI assistant specialized in home automation control through natural language. Your role is to interpret user commands and translate them into specific device control actions. Always maintain context awareness and consider user preferences and patterns. Provide clear, concise responses and suggest relevant follow-up actions.",
+        system:
+          "You are Claude, an AI assistant specialized in home automation control through natural language. Your role is to interpret user commands and translate them into specific device control actions. Always maintain context awareness and consider user preferences and patterns. Provide clear, concise responses and suggest relevant follow-up actions.",
         user: "Control the {device_name} in the {location} by {action} with parameters: {parameters}. Current context: {context}",
         examples: [
           {
             user: "Turn on the living room lights",
-                        assistant: "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?"
+            assistant:
+              "I'll turn on the lights in the living room. Would you like me to set a specific brightness level?",
           },
           {
             user: "Set the temperature to 72 degrees",
-                        assistant: "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target."
+            assistant:
+              "I'll set the temperature to 72°F. I'll monitor the temperature and let you know when it reaches the target.",
           },
           {
             user: "Open the kitchen blinds halfway",
-                        assistant: "Setting the kitchen blinds to 50% open position. Would you like me to adjust the slat angle as well?"
+            assistant:
+              "Setting the kitchen blinds to 50% open position. Would you like me to adjust the slat angle as well?",
           },
           {
             user: "Start the coffee maker",
-                        assistant: "I'll start the coffee maker in the kitchen. Based on your usual preferences, I'll use the strong brew setting. Would you like me to adjust any settings?"
+            assistant:
+              "I'll start the coffee maker in the kitchen. Based on your usual preferences, I'll use the strong brew setting. Would you like me to adjust any settings?",
           },
           {
             user: "Set up the house for bedtime",
-                        assistant: "I'll activate the bedtime routine: dimming hallway lights to 20%, turning off all other lights, setting temperature to your preferred sleeping temperature of 68°F, locking all doors, and arming the security system."
+            assistant:
+              "I'll activate the bedtime routine: dimming hallway lights to 20%, turning off all other lights, setting temperature to your preferred sleeping temperature of 68°F, locking all doors, and arming the security system.",
           },
           {
             user: "Play some music in the bedroom",
-                        assistant: "I'll start playing music on the bedroom speaker. Based on this time of day and your preferences, I'll start your 'Evening Relaxation' playlist at 40% volume. Would you like to adjust any of these settings?"
+            assistant:
+              "I'll start playing music on the bedroom speaker. Based on this time of day and your preferences, I'll start your 'Evening Relaxation' playlist at 40% volume. Would you like to adjust any of these settings?",
           },
           {
             user: "Check if I left any windows open",
-                        assistant: "I'll check all window sensors. The kitchen window and guest bedroom window are currently open. Would you like me to notify you if any windows remain open after sunset?"
+            assistant:
-                    }
+              "I'll check all window sensors. The kitchen window and guest bedroom window are currently open. Would you like me to notify you if any windows remain open after sunset?",
-                ]
+          },
-            }
+        ],
+      },
     },
     {
       name: "gpt4",
-            description: "GPT-4 specific prompt template for precise home automation control",
+      description:
+        "GPT-4 specific prompt template for precise home automation control",
       template: {
-                system: "You are a home automation assistant powered by GPT-4. Focus on precise command interpretation and execution. Maintain high accuracy in device control and parameter settings. Provide feedback on action success and system state changes.",
+        system:
+          "You are a home automation assistant powered by GPT-4. Focus on precise command interpretation and execution. Maintain high accuracy in device control and parameter settings. Provide feedback on action success and system state changes.",
         user: "Command: {action} {device_name} in {location}\nParameters: {parameters}\nContext: {context}",
         examples: [
           {
             user: "Dim the bedroom lights to 50%",
-                        assistant: "Setting bedroom light brightness to 50%. The change has been applied successfully."
+            assistant:
+              "Setting bedroom light brightness to 50%. The change has been applied successfully.",
           },
           {
             user: "Start the evening routine",
-                        assistant: "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system."
+            assistant:
+              "Initiating evening routine: dimming lights, adjusting temperature, and enabling security system.",
           },
           {
             user: "Set living room AC to 74 degrees and high fan",
-                        assistant: "Configuring living room climate control: temperature set to 74°F, fan mode set to high. Current temperature is 78°F, estimated time to target: 15 minutes."
+            assistant:
+              "Configuring living room climate control: temperature set to 74°F, fan mode set to high. Current temperature is 78°F, estimated time to target: 15 minutes.",
           },
           {
             user: "Lock all doors and windows",
-                        assistant: "Security check initiated. All 4 doors locked successfully. 6/7 windows locked. Alert: Kitchen window cannot be locked remotely - manual intervention required."
+            assistant:
+              "Security check initiated. All 4 doors locked successfully. 6/7 windows locked. Alert: Kitchen window cannot be locked remotely - manual intervention required.",
           },
           {
             user: "Turn on outdoor lights at sunset",
-                        assistant: "Scheduled task created. Outdoor lights (porch, pathway, garage) will activate at sunset (7:45 PM today). Current light sensor reading: 24,000 lux."
+            assistant:
+              "Scheduled task created. Outdoor lights (porch, pathway, garage) will activate at sunset (7:45 PM today). Current light sensor reading: 24,000 lux.",
           },
           {
             user: "Set up the media room for movie night",
-                        assistant: "Executing media room configuration: TV power on, input set to HDMI 2, surround sound activated at 40%, lights dimmed to 10%, blackout blinds closed. Room temperature adjusted to 72°F."
+            assistant:
+              "Executing media room configuration: TV power on, input set to HDMI 2, surround sound activated at 40%, lights dimmed to 10%, blackout blinds closed. Room temperature adjusted to 72°F.",
           },
           {
             user: "Show me energy usage for today",
-                        assistant: "Retrieving energy data: Total usage today: 24.5 kWh. Peak consumption: 3.2 kWh (2-3 PM). Major consumers: HVAC (45%), Water Heater (25%), Kitchen Appliances (15%)."
+            assistant:
-                    }
+              "Retrieving energy data: Total usage today: 24.5 kWh. Peak consumption: 3.2 kWh (2-3 PM). Major consumers: HVAC (45%), Water Heater (25%), Kitchen Appliances (15%).",
-                ]
+          },
-            }
+        ],
+      },
     },
     {
       name: "custom",
       description: "Customizable prompt template for home automation control",
       template: {
-                system: "Custom home automation assistant configuration. Adapt to user preferences and patterns. Learn from interactions and optimize responses. Provide detailed feedback and suggestions.",
+        system:
+          "Custom home automation assistant configuration. Adapt to user preferences and patterns. Learn from interactions and optimize responses. Provide detailed feedback and suggestions.",
         user: "Action requested: {action}\nTarget device: {device_name}\nLocation: {location}\nParameters: {parameters}\nCurrent context: {context}",
         examples: [
           {
             user: "Make it cooler in here",
-                        assistant: "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F."
+            assistant:
+              "Based on your preferences, I'll lower the temperature by 2 degrees. Current temperature is 74°F, adjusting to 72°F.",
           },
           {
             user: "Set up movie mode",
-                        assistant: "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system."
+            assistant:
+              "Activating movie mode: dimming lights to 20%, closing blinds, setting TV input to HDMI 1, and adjusting sound system.",
           },
           {
             user: "I'm heading to bed",
-                        assistant: "Initiating personalized bedtime sequence: Setting master bedroom temperature to 68°F, activating white noise machine at volume level 3, dimming hallway lights to 15%, turning off all other lights, closing all blinds, and enabling sleep mode on your phone charger."
+            assistant:
+              "Initiating personalized bedtime sequence: Setting master bedroom temperature to 68°F, activating white noise machine at volume level 3, dimming hallway lights to 15%, turning off all other lights, closing all blinds, and enabling sleep mode on your phone charger.",
           },
           {
             user: "Start my morning routine",
-                        assistant: "Good morning! Executing your weekday morning routine: Gradually increasing bedroom lights (now at 30%), starting coffee maker with your weekday strength setting, setting bathroom heater to 72°F, and pulling up today's weather and calendar on your kitchen display."
+            assistant:
+              "Good morning! Executing your weekday morning routine: Gradually increasing bedroom lights (now at 30%), starting coffee maker with your weekday strength setting, setting bathroom heater to 72°F, and pulling up today's weather and calendar on your kitchen display.",
           },
           {
             user: "I'm working from home today",
-                        assistant: "Activating work-from-home environment: Setting home office lights to your preferred 5000K color temperature at 80% brightness, adjusting HVAC for daytime occupancy, enabling do-not-disturb on doorbell, and configuring automated breaks reminder every 2 hours."
+            assistant:
+              "Activating work-from-home environment: Setting home office lights to your preferred 5000K color temperature at 80% brightness, adjusting HVAC for daytime occupancy, enabling do-not-disturb on doorbell, and configuring automated breaks reminder every 2 hours.",
           },
           {
             user: "We're having guests over",
-                        assistant: "Preparing home for guests: Adjusting living room and dining room temperature to 72°F, setting accent lighting to warm white (2700K), activating air purifier in high mode, enabling guest WiFi network, and preheating the oven as per your usual entertaining preferences."
+            assistant:
+              "Preparing home for guests: Adjusting living room and dining room temperature to 72°F, setting accent lighting to warm white (2700K), activating air purifier in high mode, enabling guest WiFi network, and preheating the oven as per your usual entertaining preferences.",
           },
           {
             user: "Monitor the baby's room",
-                        assistant: "Activating enhanced nursery monitoring: Setting up temperature alerts (68-72°F range), enabling sound monitoring with smart notification threshold, maintaining humidity at 50%, and activating the smart night light with color changing based on sleep schedule. Current readings: 70°F, 48% humidity, sound level: minimal."
+            assistant:
-                    }
+              "Activating enhanced nursery monitoring: Setting up temperature alerts (68-72°F range), enabling sound monitoring with smart notification threshold, maintaining humidity at 50%, and activating the smart night light with color changing based on sleep schedule. Current readings: 70°F, 48% humidity, sound level: minimal.",
-                ]
+          },
+        ],
       },
       variables: {
         device_name: "string",
         location: "string",
         action: "string",
         parameters: "object",
-                context: "object"
+        context: "object",
-            }
+      },
-        }
+    },
   ],
   resources: [
     {
       name: "Home Assistant API",
-            url: "https://developers.home-assistant.io/docs/api/rest/"
+      url: "https://developers.home-assistant.io/docs/api/rest/",
     },
     {
       name: "Home Assistant WebSocket API",
-            url: "https://developers.home-assistant.io/docs/api/websocket"
+      url: "https://developers.home-assistant.io/docs/api/websocket",
     },
     {
       name: "HACS Documentation",
-            url: "https://hacs.xyz"
+      url: "https://hacs.xyz",
-        }
+    },
-    ]
+  ],
 };

src/middleware/__tests__/security.middleware.test.ts

@@ -1,11 +1,11 @@
-import { Request, Response } from 'express';
+import { Request, Response } from "express";
-import { validateRequest, sanitizeInput, errorHandler } from '../index';
+import { validateRequest, sanitizeInput, errorHandler } from "../index";
-import { TokenManager } from '../../security/index';
+import { TokenManager } from "../../security/index";
-import { jest } from '@jest/globals';
+import { jest } from "@jest/globals";
 
-const TEST_SECRET = 'test-secret-that-is-long-enough-for-testing-purposes';
+const TEST_SECRET = "test-secret-that-is-long-enough-for-testing-purposes";
 
-describe('Security Middleware', () => {
+describe("Security Middleware", () => {
   let mockRequest: Partial<Request>;
   let mockResponse: Partial<Response>;
   let nextFunction: jest.Mock;
@@ -13,10 +13,10 @@ describe('Security Middleware', () => {
   beforeEach(() => {
     process.env.JWT_SECRET = TEST_SECRET;
     mockRequest = {
-            method: 'POST',
+      method: "POST",
       headers: {},
       body: {},
-            ip: '127.0.0.1'
+      ip: "127.0.0.1",
     };
 
     const mockJson = jest.fn().mockReturnThis();
@@ -28,7 +28,7 @@ describe('Security Middleware', () => {
       status: mockStatus as any,
       json: mockJson as any,
       setHeader: mockSetHeader as any,
-            removeHeader: mockRemoveHeader as any
+      removeHeader: mockRemoveHeader as any,
     };
     nextFunction = jest.fn();
   });
@@ -38,125 +38,165 @@ describe('Security Middleware', () => {
     jest.clearAllMocks();
   });
 
-    describe('Request Validation', () => {
+  describe("Request Validation", () => {
-        it('should pass valid requests', () => {
+    it("should pass valid requests", () => {
       mockRequest.headers = {
-                'authorization': 'Bearer valid-token',
+        authorization: "Bearer valid-token",
-                'content-type': 'application/json'
+        "content-type": "application/json",
       };
-            jest.spyOn(TokenManager, 'validateToken').mockReturnValue({ valid: true });
+      jest
+        .spyOn(TokenManager, "validateToken")
+        .mockReturnValue({ valid: true });
 
-            validateRequest(mockRequest as Request, mockResponse as Response, nextFunction);
+      validateRequest(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should reject requests without authorization header', () => {
+    it("should reject requests without authorization header", () => {
-            validateRequest(mockRequest as Request, mockResponse as Response, nextFunction);
+      validateRequest(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(401);
       expect(mockResponse.json).toHaveBeenCalledWith({
         success: false,
-                message: 'Unauthorized',
+        message: "Unauthorized",
-                error: 'Missing or invalid authorization header',
+        error: "Missing or invalid authorization header",
-                timestamp: expect.any(String)
+        timestamp: expect.any(String),
       });
     });
 
-        it('should reject requests with invalid authorization format', () => {
+    it("should reject requests with invalid authorization format", () => {
       mockRequest.headers = {
-                'authorization': 'invalid-format',
+        authorization: "invalid-format",
-                'content-type': 'application/json'
+        "content-type": "application/json",
       };
-            validateRequest(mockRequest as Request, mockResponse as Response, nextFunction);
+      validateRequest(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(401);
       expect(mockResponse.json).toHaveBeenCalledWith({
         success: false,
-                message: 'Unauthorized',
+        message: "Unauthorized",
-                error: 'Missing or invalid authorization header',
+        error: "Missing or invalid authorization header",
-                timestamp: expect.any(String)
+        timestamp: expect.any(String),
       });
     });
 
-        it('should reject oversized requests', () => {
+    it("should reject oversized requests", () => {
       mockRequest.headers = {
-                'authorization': 'Bearer valid-token',
+        authorization: "Bearer valid-token",
-                'content-type': 'application/json',
+        "content-type": "application/json",
-                'content-length': '1048577' // 1MB + 1 byte
+        "content-length": "1048577", // 1MB + 1 byte
       };
-            validateRequest(mockRequest as Request, mockResponse as Response, nextFunction);
+      validateRequest(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(413);
       expect(mockResponse.json).toHaveBeenCalledWith({
         success: false,
-                message: 'Payload Too Large',
+        message: "Payload Too Large",
-                error: 'Request body must not exceed 1048576 bytes',
+        error: "Request body must not exceed 1048576 bytes",
-                timestamp: expect.any(String)
+        timestamp: expect.any(String),
       });
     });
   });
 
-    describe('Input Sanitization', () => {
+  describe("Input Sanitization", () => {
-        it('should sanitize HTML in request body', () => {
+    it("should sanitize HTML in request body", () => {
       mockRequest.body = {
         text: 'Test <script>alert("xss")</script>',
         nested: {
-                    html: '<img src="x" onerror="alert(1)">World'
+          html: '<img src="x" onerror="alert(1)">World',
-                }
+        },
       };
-            sanitizeInput(mockRequest as Request, mockResponse as Response, nextFunction);
+      sanitizeInput(
-            expect(mockRequest.body.text).toBe('Test ');
+        mockRequest as Request,
-            expect(mockRequest.body.nested.html).toBe('World');
+        mockResponse as Response,
+        nextFunction,
+      );
+      expect(mockRequest.body.text).toBe("Test ");
+      expect(mockRequest.body.nested.html).toBe("World");
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should handle non-object bodies', () => {
+    it("should handle non-object bodies", () => {
-            mockRequest.body = '<p>text</p>';
+      mockRequest.body = "<p>text</p>";
-            sanitizeInput(mockRequest as Request, mockResponse as Response, nextFunction);
+      sanitizeInput(
-            expect(mockRequest.body).toBe('text');
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
+      expect(mockRequest.body).toBe("text");
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should preserve non-string values', () => {
+    it("should preserve non-string values", () => {
       mockRequest.body = {
         number: 123,
         boolean: true,
         array: [1, 2, 3],
-                nested: { value: 456 }
+        nested: { value: 456 },
       };
-            sanitizeInput(mockRequest as Request, mockResponse as Response, nextFunction);
+      sanitizeInput(
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockRequest.body).toEqual({
         number: 123,
         boolean: true,
         array: [1, 2, 3],
-                nested: { value: 456 }
+        nested: { value: 456 },
       });
       expect(nextFunction).toHaveBeenCalled();
     });
   });
 
-    describe('Error Handler', () => {
+  describe("Error Handler", () => {
-        it('should handle errors in production mode', () => {
+    it("should handle errors in production mode", () => {
-            process.env.NODE_ENV = 'production';
+      process.env.NODE_ENV = "production";
-            const error = new Error('Test error');
+      const error = new Error("Test error");
-            errorHandler(error, mockRequest as Request, mockResponse as Response, nextFunction);
+      errorHandler(
+        error,
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(500);
       expect(mockResponse.json).toHaveBeenCalledWith({
         success: false,
-                message: 'Internal Server Error',
+        message: "Internal Server Error",
-                error: 'An unexpected error occurred',
+        error: "An unexpected error occurred",
-                timestamp: expect.any(String)
+        timestamp: expect.any(String),
       });
     });
 
-        it('should include error details in development mode', () => {
+    it("should include error details in development mode", () => {
-            process.env.NODE_ENV = 'development';
+      process.env.NODE_ENV = "development";
-            const error = new Error('Test error');
+      const error = new Error("Test error");
-            errorHandler(error, mockRequest as Request, mockResponse as Response, nextFunction);
+      errorHandler(
+        error,
+        mockRequest as Request,
+        mockResponse as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(500);
       expect(mockResponse.json).toHaveBeenCalledWith({
         success: false,
-                message: 'Internal Server Error',
+        message: "Internal Server Error",
-                error: 'Test error',
+        error: "Test error",
         stack: expect.any(String),
-                timestamp: expect.any(String)
+        timestamp: expect.any(String),
       });
     });
   });

src/middleware/index.ts

@@ -1,10 +1,10 @@
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
-import { HASS_CONFIG, RATE_LIMIT_CONFIG } from '../config/index.js';
+import { HASS_CONFIG, RATE_LIMIT_CONFIG } from "../config/index.js";
-import rateLimit from 'express-rate-limit';
+import rateLimit from "express-rate-limit";
-import { TokenManager } from '../security/index.js';
+import { TokenManager } from "../security/index.js";
-import sanitizeHtml from 'sanitize-html';
+import sanitizeHtml from "sanitize-html";
-import helmet from 'helmet';
+import helmet from "helmet";
-import { SECURITY_CONFIG } from '../config/security.config.js';
+import { SECURITY_CONFIG } from "../config/security.config.js";
 
 // Rate limiter middleware with enhanced configuration
 export const rateLimiter = rateLimit({
@@ -12,10 +12,10 @@ export const rateLimiter = rateLimit({
   max: SECURITY_CONFIG.RATE_LIMIT_MAX_REQUESTS,
   message: {
     success: false,
-        message: 'Too Many Requests',
+    message: "Too Many Requests",
-        error: 'Rate limit exceeded. Please try again later.',
+    error: "Rate limit exceeded. Please try again later.",
-        timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
-    }
+  },
 });
 
 // WebSocket rate limiter middleware with enhanced configuration
@@ -26,36 +26,40 @@ export const wsRateLimiter = rateLimit({
   legacyHeaders: false,
   message: {
     success: false,
-        message: 'Too many WebSocket connections, please try again later.',
+    message: "Too many WebSocket connections, please try again later.",
-        reset_time: new Date(Date.now() + 60 * 1000).toISOString()
+    reset_time: new Date(Date.now() + 60 * 1000).toISOString(),
   },
   skipSuccessfulRequests: false,
-    keyGenerator: (req) => req.ip || req.socket.remoteAddress || 'unknown'
+  keyGenerator: (req) => req.ip || req.socket.remoteAddress || "unknown",
 });
 
 // Authentication middleware with enhanced security
-export const authenticate = (req: Request, res: Response, next: NextFunction) => {
+export const authenticate = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
   const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: 'Missing or invalid authorization header',
+      error: "Missing or invalid authorization header",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
-    const token = authHeader.replace('Bearer ', '');
+  const token = authHeader.replace("Bearer ", "");
-    const clientIp = req.ip || req.socket.remoteAddress || '';
+  const clientIp = req.ip || req.socket.remoteAddress || "";
 
   const validationResult = TokenManager.validateToken(token, clientIp);
 
   if (!validationResult.valid) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: validationResult.error || 'Invalid token',
+      error: validationResult.error || "Invalid token",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
@@ -69,46 +73,52 @@ const helmetMiddleware = helmet({
       defaultSrc: ["'self'"],
       scriptSrc: ["'self'", "'unsafe-inline'"],
       styleSrc: ["'self'", "'unsafe-inline'"],
-            imgSrc: ["'self'", 'data:', 'https:'],
+      imgSrc: ["'self'", "data:", "https:"],
-            connectSrc: ["'self'", 'wss:', 'https:'],
+      connectSrc: ["'self'", "wss:", "https:"],
       frameSrc: ["'none'"],
       objectSrc: ["'none'"],
       baseUri: ["'self'"],
       formAction: ["'self'"],
-            frameAncestors: ["'none'"]
+      frameAncestors: ["'none'"],
-        }
+    },
   },
   crossOriginEmbedderPolicy: true,
-    crossOriginOpenerPolicy: { policy: 'same-origin' },
+  crossOriginOpenerPolicy: { policy: "same-origin" },
-    crossOriginResourcePolicy: { policy: 'same-origin' },
+  crossOriginResourcePolicy: { policy: "same-origin" },
   dnsPrefetchControl: { allow: false },
-    frameguard: { action: 'deny' },
+  frameguard: { action: "deny" },
   hidePoweredBy: true,
   hsts: {
     maxAge: 31536000,
     includeSubDomains: true,
-        preload: true
+    preload: true,
   },
   ieNoOpen: true,
   noSniff: true,
   originAgentCluster: true,
-    permittedCrossDomainPolicies: { permittedPolicies: 'none' },
+  permittedCrossDomainPolicies: { permittedPolicies: "none" },
-    referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
+  referrerPolicy: { policy: "strict-origin-when-cross-origin" },
-    xssFilter: true
+  xssFilter: true,
 });
 
 // Wrapper for helmet middleware to handle mock responses in tests
-export const securityHeaders = (req: Request, res: Response, next: NextFunction): void => {
+export const securityHeaders = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
   // Basic security headers
-    res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader("X-Content-Type-Options", "nosniff");
-    res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader("X-Frame-Options", "DENY");
-    res.setHeader('X-XSS-Protection', '1; mode=block');
+  res.setHeader("X-XSS-Protection", "1; mode=block");
-    res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+  res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
-    res.setHeader('X-Permitted-Cross-Domain-Policies', 'none');
+  res.setHeader("X-Permitted-Cross-Domain-Policies", "none");
-    res.setHeader('X-Download-Options', 'noopen');
+  res.setHeader("X-Download-Options", "noopen");
 
   // Content Security Policy
-    res.setHeader('Content-Security-Policy', [
+  res.setHeader(
+    "Content-Security-Policy",
+    [
       "default-src 'self'",
       "script-src 'self'",
       "style-src 'self'",
@@ -119,12 +129,16 @@ export const securityHeaders = (req: Request, res: Response, next: NextFunction)
       "object-src 'none'",
       "frame-ancestors 'none'",
       "base-uri 'self'",
-        "form-action 'self'"
+      "form-action 'self'",
-    ].join('; '));
+    ].join("; "),
+  );
 
   // HSTS (only in production)
-    if (process.env.NODE_ENV === 'production') {
+  if (process.env.NODE_ENV === "production") {
-        res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
+    res.setHeader(
+      "Strict-Transport-Security",
+      "max-age=31536000; includeSubDomains; preload",
+    );
   }
 
   next();
@@ -133,56 +147,60 @@ export const securityHeaders = (req: Request, res: Response, next: NextFunction)
 /**
  * Validates incoming requests for proper authentication and content type
  */
-export const validateRequest = (req: Request, res: Response, next: NextFunction): Response | void => {
+export const validateRequest = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Response | void => {
   // Skip validation for health and MCP schema endpoints
-    if (req.path === '/health' || req.path === '/mcp') {
+  if (req.path === "/health" || req.path === "/mcp") {
     return next();
   }
 
   // Validate content type for non-GET requests
-    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+  if (["POST", "PUT", "PATCH"].includes(req.method)) {
-        const contentType = req.headers['content-type'] || '';
+    const contentType = req.headers["content-type"] || "";
-        if (!contentType.toLowerCase().includes('application/json')) {
+    if (!contentType.toLowerCase().includes("application/json")) {
       return res.status(415).json({
         success: false,
-                message: 'Unsupported Media Type',
+        message: "Unsupported Media Type",
-                error: 'Content-Type must be application/json',
+        error: "Content-Type must be application/json",
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
   }
 
   // Validate authorization header
   const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: 'Missing or invalid authorization header',
+      error: "Missing or invalid authorization header",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
   // Validate token
-    const token = authHeader.replace('Bearer ', '');
+  const token = authHeader.replace("Bearer ", "");
   const validationResult = TokenManager.validateToken(token, req.ip);
   if (!validationResult.valid) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: validationResult.error || 'Invalid token',
+      error: validationResult.error || "Invalid token",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
   // Validate request body structure
-    if (req.method !== 'GET' && req.body) {
+  if (req.method !== "GET" && req.body) {
-        if (typeof req.body !== 'object' || Array.isArray(req.body)) {
+    if (typeof req.body !== "object" || Array.isArray(req.body)) {
       return res.status(400).json({
         success: false,
-                message: 'Bad Request',
+        message: "Bad Request",
-                error: 'Invalid request body structure',
+        error: "Invalid request body structure",
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
   }
@@ -193,28 +211,43 @@ export const validateRequest = (req: Request, res: Response, next: NextFunction)
 /**
  * Sanitizes input data to prevent XSS attacks
  */
-export const sanitizeInput = (req: Request, res: Response, next: NextFunction): void => {
+export const sanitizeInput = (
-    if (req.body && typeof req.body === 'object' && !Array.isArray(req.body)) {
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
+  if (req.body && typeof req.body === "object" && !Array.isArray(req.body)) {
     const sanitizeValue = (value: unknown): unknown => {
-            if (typeof value === 'string') {
+      if (typeof value === "string") {
         let sanitized = value;
         // Remove script tags and their content
-                sanitized = sanitized.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
+        sanitized = sanitized.replace(
+          /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+          "",
+        );
         // Remove style tags and their content
-                sanitized = sanitized.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '');
+        sanitized = sanitized.replace(
+          /<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi,
+          "",
+        );
         // Remove remaining HTML tags
-                sanitized = sanitized.replace(/<[^>]+>/g, '');
+        sanitized = sanitized.replace(/<[^>]+>/g, "");
         // Remove javascript: protocol
-                sanitized = sanitized.replace(/javascript:/gi, '');
+        sanitized = sanitized.replace(/javascript:/gi, "");
         // Remove event handlers
-                sanitized = sanitized.replace(/on\w+\s*=\s*(?:".*?"|'.*?'|[^"'>\s]+)/gi, '');
+        sanitized = sanitized.replace(
+          /on\w+\s*=\s*(?:".*?"|'.*?'|[^"'>\s]+)/gi,
+          "",
+        );
         // Trim whitespace
         return sanitized.trim();
-            } else if (typeof value === 'object' && value !== null) {
+      } else if (typeof value === "object" && value !== null) {
         const result: Record<string, unknown> = {};
-                Object.entries(value as Record<string, unknown>).forEach(([key, val]) => {
+        Object.entries(value as Record<string, unknown>).forEach(
+          ([key, val]) => {
             result[key] = sanitizeValue(val);
-                });
+          },
+        );
         return result;
       }
       return value;
@@ -228,12 +261,17 @@ export const sanitizeInput = (req: Request, res: Response, next: NextFunction):
 /**
  * Handles errors in a consistent way
  */
-export const errorHandler = (err: Error, req: Request, res: Response, next: NextFunction): Response => {
+export const errorHandler = (
-    const isDevelopment = process.env.NODE_ENV === 'development';
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Response => {
+  const isDevelopment = process.env.NODE_ENV === "development";
   const response: Record<string, unknown> = {
     success: false,
-        message: 'Internal Server Error',
+    message: "Internal Server Error",
-        timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   };
 
   if (isDevelopment) {
@@ -252,5 +290,5 @@ export const middleware = {
   validateRequest,
   sanitizeInput,
   authenticate,
-    errorHandler
+  errorHandler,
 };

src/middleware/logging.middleware.ts

@@ -7,9 +7,9 @@
  * @module logging-middleware
  */
 
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
-import { logger } from '../utils/logger.js';
+import { logger } from "../utils/logger.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 /**
  * Interface for extended request object with timing information
@@ -37,9 +37,9 @@ const getResponseTime = (startTime: number): number => {
  */
 const getClientIp = (req: Request): string => {
   return (
-        (req.headers['x-forwarded-for'] as string)?.split(',')[0] ||
+    (req.headers["x-forwarded-for"] as string)?.split(",")[0] ||
     req.socket.remoteAddress ||
-        'unknown'
+    "unknown"
   );
 };
 
@@ -59,7 +59,11 @@ const formatRequestLog = (req: TimedRequest): string => {
  * @param time - Response time in milliseconds
  * @returns Formatted log message
  */
-const formatResponseLog = (req: TimedRequest, res: Response, time: number): string => {
+const formatResponseLog = (
+  req: TimedRequest,
+  res: Response,
+  time: number,
+): string => {
   return `${req.method} ${req.originalUrl} - ${res.statusCode} - ${time.toFixed(2)}ms`;
 };
 
@@ -67,7 +71,11 @@ const formatResponseLog = (req: TimedRequest, res: Response, time: number): stri
  * Request logging middleware
  * Logs information about incoming requests and their responses
  */
-export const requestLogger = (req: TimedRequest, res: Response, next: NextFunction): void => {
+export const requestLogger = (
+  req: TimedRequest,
+  res: Response,
+  next: NextFunction,
+): void => {
   if (!APP_CONFIG.LOGGING.LOG_REQUESTS) {
     next();
     return;
@@ -80,9 +88,9 @@ export const requestLogger = (req: TimedRequest, res: Response, next: NextFuncti
   logger.http(formatRequestLog(req));
 
   // Log response
-    res.on('finish', () => {
+  res.on("finish", () => {
     const responseTime = Date.now() - (req.startTime || 0);
-        const logLevel = res.statusCode >= 400 ? 'warn' : 'http';
+    const logLevel = res.statusCode >= 400 ? "warn" : "http";
     logger[logLevel](formatResponseLog(req, res, responseTime));
   });
 
@@ -93,14 +101,22 @@ export const requestLogger = (req: TimedRequest, res: Response, next: NextFuncti
  * Error logging middleware
  * Logs errors that occur during request processing
  */
-export const errorLogger = (err: Error, req: Request, res: Response, next: NextFunction): void => {
+export const errorLogger = (
-    logger.error(`Error processing ${req.method} ${req.originalUrl}: ${err.message}`, {
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
+  logger.error(
+    `Error processing ${req.method} ${req.originalUrl}: ${err.message}`,
+    {
       error: err.stack,
       method: req.method,
       url: req.originalUrl,
       body: req.body,
       query: req.query,
-        ip: getClientIp(req)
+      ip: getClientIp(req),
-    });
+    },
+  );
   next(err);
 };

src/platforms/macos/integration.ts

@@ -1,6 +1,6 @@
-import { exec } from 'child_process';
+import { exec } from "child_process";
-import { promisify } from 'util';
+import { promisify } from "util";
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 
 const execAsync = promisify(exec);
 
@@ -25,7 +25,7 @@ class MacOSIntegration extends EventEmitter {
     this.permissions = {
       notifications: false,
       automation: false,
-            accessibility: false
+      accessibility: false,
     };
   }
 
@@ -38,51 +38,55 @@ class MacOSIntegration extends EventEmitter {
     try {
       // Check notification permissions
       const { stdout: notifPerms } = await execAsync(
-                'osascript -e \'tell application "System Events" to get properties\''
+        "osascript -e 'tell application \"System Events\" to get properties'",
+      );
+      this.permissions.notifications = notifPerms.includes(
+        "notifications enabled:true",
       );
-            this.permissions.notifications = notifPerms.includes('notifications enabled:true');
 
       // Check automation permissions
       const { stdout: autoPerms } = await execAsync(
-                'osascript -e \'tell application "System Events" to get UI elements enabled\''
+        "osascript -e 'tell application \"System Events\" to get UI elements enabled'",
       );
-            this.permissions.automation = autoPerms.includes('true');
+      this.permissions.automation = autoPerms.includes("true");
 
       // Check accessibility permissions
       const { stdout: accessPerms } = await execAsync(
-                'osascript -e \'tell application "System Events" to get processes\''
+        "osascript -e 'tell application \"System Events\" to get processes'",
       );
-            this.permissions.accessibility = !accessPerms.includes('error');
+      this.permissions.accessibility = !accessPerms.includes("error");
 
       return this.permissions;
     } catch (error) {
-            console.error('Error checking permissions:', error);
+      console.error("Error checking permissions:", error);
       return this.permissions;
     }
   }
 
   async sendNotification(notification: MacOSNotification): Promise<void> {
     if (!this.permissions.notifications) {
-            throw new Error('Notification permission not granted');
+      throw new Error("Notification permission not granted");
     }
 
     const script = `
-      display notification "${notification.message}"${notification.subtitle ? ` with subtitle "${notification.subtitle}"` : ''
+      display notification "${notification.message}"${
-            } with title "${notification.title}"${notification.sound ? ' sound name "default"' : ''
+        notification.subtitle ? ` with subtitle "${notification.subtitle}"` : ""
+      } with title "${notification.title}"${
+        notification.sound ? ' sound name "default"' : ""
       }
     `;
 
     try {
       await execAsync(`osascript -e '${script}'`);
     } catch (error) {
-            console.error('Error sending notification:', error);
+      console.error("Error sending notification:", error);
       throw error;
     }
   }
 
   async registerSystemEvents(): Promise<void> {
     if (!this.permissions.automation) {
-            throw new Error('Automation permission not granted');
+      throw new Error("Automation permission not granted");
     }
 
     // Monitor system events
@@ -112,23 +116,23 @@ class MacOSIntegration extends EventEmitter {
 
     try {
       const { stdout } = await execAsync(`osascript -e '${script}'`);
-            const events = stdout.split(',').map(e => e.trim());
+      const events = stdout.split(",").map((e) => e.trim());
-            events.forEach(event => this.emit('system_event', event));
+      events.forEach((event) => this.emit("system_event", event));
     } catch (error) {
-            console.error('Error monitoring system events:', error);
+      console.error("Error monitoring system events:", error);
     }
   }
 
   async executeAutomation(script: string): Promise<string> {
     if (!this.permissions.automation) {
-            throw new Error('Automation permission not granted');
+      throw new Error("Automation permission not granted");
     }
 
     try {
       const { stdout } = await execAsync(`osascript -e '${script}'`);
       return stdout;
     } catch (error) {
-            console.error('Error executing automation:', error);
+      console.error("Error executing automation:", error);
       throw error;
     }
   }
@@ -138,36 +142,40 @@ class MacOSIntegration extends EventEmitter {
 
     try {
       // Get macOS version
-            const { stdout: version } = await execAsync('sw_vers -productVersion');
+      const { stdout: version } = await execAsync("sw_vers -productVersion");
       info.os_version = version.trim();
 
       // Get hardware info
-            const { stdout: hardware } = await execAsync('system_profiler SPHardwareDataType');
+      const { stdout: hardware } = await execAsync(
+        "system_profiler SPHardwareDataType",
+      );
       info.hardware = this.parseSystemProfile(hardware);
 
       // Get power info
-            const { stdout: power } = await execAsync('pmset -g batt');
+      const { stdout: power } = await execAsync("pmset -g batt");
       info.power = this.parsePowerInfo(power);
 
       // Get network info
-            const { stdout: network } = await execAsync('networksetup -listallhardwareports');
+      const { stdout: network } = await execAsync(
+        "networksetup -listallhardwareports",
+      );
       info.network = this.parseNetworkInfo(network);
 
       return info;
     } catch (error) {
-            console.error('Error getting system info:', error);
+      console.error("Error getting system info:", error);
       throw error;
     }
   }
 
   private parseSystemProfile(output: string): Record<string, any> {
     const info: Record<string, any> = {};
-        const lines = output.split('\n');
+    const lines = output.split("\n");
 
     for (const line of lines) {
-            const [key, value] = line.split(':').map(s => s.trim());
+      const [key, value] = line.split(":").map((s) => s.trim());
       if (key && value) {
-                info[key.toLowerCase().replace(/\s+/g, '_')] = value;
+        info[key.toLowerCase().replace(/\s+/g, "_")] = value;
       }
     }
 
@@ -176,12 +184,12 @@ class MacOSIntegration extends EventEmitter {
 
   private parsePowerInfo(output: string): Record<string, any> {
     const info: Record<string, any> = {};
-        const lines = output.split('\n');
+    const lines = output.split("\n");
 
     for (const line of lines) {
-            if (line.includes('Now drawing from')) {
+      if (line.includes("Now drawing from")) {
-                info.power_source = line.includes('Battery') ? 'battery' : 'ac_power';
+        info.power_source = line.includes("Battery") ? "battery" : "ac_power";
-            } else if (line.includes('%')) {
+      } else if (line.includes("%")) {
         const matches = line.match(/(\d+)%/);
         if (matches) {
           info.battery_percentage = parseInt(matches[1]);
@@ -194,17 +202,17 @@ class MacOSIntegration extends EventEmitter {
 
   private parseNetworkInfo(output: string): Record<string, any> {
     const info: Record<string, any> = {};
-        const lines = output.split('\n');
+    const lines = output.split("\n");
     let currentInterface: string | null = null;
 
     for (const line of lines) {
-            if (line.includes('Hardware Port:')) {
+      if (line.includes("Hardware Port:")) {
-                currentInterface = line.split(':')[1].trim();
+        currentInterface = line.split(":")[1].trim();
         info[currentInterface] = {};
-            } else if (currentInterface && line.includes('Device:')) {
+      } else if (currentInterface && line.includes("Device:")) {
-                info[currentInterface].device = line.split(':')[1].trim();
+        info[currentInterface].device = line.split(":")[1].trim();
-            } else if (currentInterface && line.includes('Ethernet Address:')) {
+      } else if (currentInterface && line.includes("Ethernet Address:")) {
-                info[currentInterface].mac = line.split(':')[1].trim();
+        info[currentInterface].mac = line.split(":")[1].trim();
       }
     }
 

src/routes/health.routes.ts

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

src/routes/index.ts

@@ -8,11 +8,11 @@
  * @module routes
  */
 
-import { Router } from 'express';
+import { Router } from "express";
-import { mcpRoutes } from './mcp.routes.js';
+import { mcpRoutes } from "./mcp.routes.js";
-import { sseRoutes } from './sse.routes.js';
+import { sseRoutes } from "./sse.routes.js";
-import { toolRoutes } from './tool.routes.js';
+import { toolRoutes } from "./tool.routes.js";
-import { healthRoutes } from './health.routes.js';
+import { healthRoutes } from "./health.routes.js";
 
 /**
  * Create main router instance
@@ -27,10 +27,10 @@ const router = Router();
  * - /tools: Tool management endpoints
  * - /health: Health check endpoint
  */
-router.use('/mcp', mcpRoutes);
+router.use("/mcp", mcpRoutes);
-router.use('/sse', sseRoutes);
+router.use("/sse", sseRoutes);
-router.use('/tools', toolRoutes);
+router.use("/tools", toolRoutes);
-router.use('/health', healthRoutes);
+router.use("/health", healthRoutes);
 
 /**
  * Export the configured router

src/routes/mcp.routes.ts

@@ -7,10 +7,10 @@
  * @module mcp-routes
  */
 
-import { Router } from 'express';
+import { Router } from "express";
-import { MCP_SCHEMA } from '../mcp/schema.js';
+import { MCP_SCHEMA } from "../mcp/schema.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { Tool } from '../types/index.js';
+import { Tool } from "../types/index.js";
 
 /**
  * Create router instance for MCP routes
@@ -28,7 +28,7 @@ const tools: Tool[] = [];
  * Returns the MCP schema without requiring authentication
  * This endpoint allows clients to discover available tools and their parameters
  */
-router.get('/', (_req, res) => {
+router.get("/", (_req, res) => {
   res.json(MCP_SCHEMA);
 });
 
@@ -44,26 +44,26 @@ router.get('/', (_req, res) => {
  * @throws {404} If tool is not found
  * @throws {500} If execution fails
  */
-router.post('/execute', async (req, res) => {
+router.post("/execute", async (req, res) => {
   try {
     // Get token from Authorization header
-        const token = req.headers.authorization?.replace('Bearer ', '');
+    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'
+        message: "Unauthorized - Invalid token",
       });
     }
 
     const { tool: toolName, parameters } = req.body;
 
     // Find the requested tool
-        const tool = tools.find(t => t.name === toolName);
+    const tool = tools.find((t) => t.name === toolName);
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: `Tool '${toolName}' not found`
+        message: `Tool '${toolName}' not found`,
       });
     }
 
@@ -73,7 +73,8 @@ router.post('/execute', async (req, res) => {
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });

src/routes/sse.routes.ts

@@ -1,44 +1,46 @@
-import { Router } from 'express';
+import { Router } from "express";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
-import { sseManager } from '../sse/index.js';
+import { sseManager } from "../sse/index.js";
-import { TokenManager } from '../security/index.js';
+import { TokenManager } from "../security/index.js";
-import { middleware } from '../middleware/index.js';
+import { middleware } from "../middleware/index.js";
 
 const router = Router();
 
 // SSE endpoints
-router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
+router.get("/subscribe_events", middleware.wsRateLimiter, (req, res) => {
   try {
     // Get token from query parameter and validate
-        const token = req.query.token?.toString() || '';
+    const token = req.query.token?.toString() || "";
-        const clientIp = req.ip || req.socket.remoteAddress || '';
+    const clientIp = req.ip || req.socket.remoteAddress || "";
     const validationResult = TokenManager.validateToken(token, clientIp);
 
     if (!validationResult.valid) {
       return res.status(401).json({
         success: false,
-                message: 'Unauthorized',
+        message: "Unauthorized",
         error: validationResult.error,
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
 
     // Set SSE headers with enhanced security
     res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
+      "Content-Type": "text/event-stream",
-            'Cache-Control': 'no-cache, no-transform',
+      "Cache-Control": "no-cache, no-transform",
-            'Connection': 'keep-alive',
+      Connection: "keep-alive",
-            'X-Accel-Buffering': 'no',
+      "X-Accel-Buffering": "no",
-            'Access-Control-Allow-Origin': '*',
+      "Access-Control-Allow-Origin": "*",
-            'Access-Control-Allow-Credentials': 'true'
+      "Access-Control-Allow-Credentials": "true",
     });
 
     // Send initial connection message
-        res.write(`data: ${JSON.stringify({
+    res.write(
-            type: 'connection',
+      `data: ${JSON.stringify({
-            status: 'connected',
+        type: "connection",
-            timestamp: new Date().toISOString()
+        status: "connected",
-        })}\n\n`);
+        timestamp: new Date().toISOString(),
+      })}\n\n`,
+    );
 
     const clientId = uuidv4();
     const client = {
@@ -47,60 +49,65 @@ router.get('/subscribe_events', middleware.wsRateLimiter, (req, res) => {
       connectedAt: new Date(),
       send: (data: string) => {
         res.write(`data: ${data}\n\n`);
-            }
+      },
     };
 
     // Add client to SSE manager with enhanced tracking
     const sseClient = sseManager.addClient(client, token);
     if (!sseClient || !sseClient.authenticated) {
       const errorMessage = JSON.stringify({
-                type: 'error',
+        type: "error",
-                message: sseClient ? 'Authentication failed' : 'Maximum client limit reached',
+        message: sseClient
-                timestamp: new Date().toISOString()
+          ? "Authentication failed"
+          : "Maximum client limit reached",
+        timestamp: new Date().toISOString(),
       });
       res.write(`data: ${errorMessage}\n\n`);
       return res.end();
     }
 
     // Handle client disconnect
-        req.on('close', () => {
+    req.on("close", () => {
       sseManager.removeClient(clientId);
-            console.log(`Client ${clientId} disconnected at ${new Date().toISOString()}`);
+      console.log(
+        `Client ${clientId} disconnected at ${new Date().toISOString()}`,
+      );
     });
 
     // Handle errors
-        req.on('error', (error) => {
+    req.on("error", (error) => {
       console.error(`SSE Error for client ${clientId}:`, error);
       const errorMessage = JSON.stringify({
-                type: 'error',
+        type: "error",
-                message: 'Connection error',
+        message: "Connection error",
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
       res.write(`data: ${errorMessage}\n\n`);
       sseManager.removeClient(clientId);
       res.end();
     });
-
   } catch (error) {
-        console.error('SSE Setup Error:', error);
+    console.error("SSE Setup Error:", error);
     res.status(500).json({
       success: false,
-            message: 'Internal Server Error',
+      message: "Internal Server Error",
-            error: error instanceof Error ? error.message : 'An unexpected error occurred',
+      error:
-            timestamp: new Date().toISOString()
+        error instanceof Error ? error.message : "An unexpected error occurred",
+      timestamp: new Date().toISOString(),
     });
   }
 });
 
 // Get SSE stats endpoint
-router.get('/stats', async (req, res) => {
+router.get("/stats", async (req, res) => {
   try {
     const stats = await sseManager.getStatistics();
     res.json(stats);
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });

src/routes/tool.routes.ts

@@ -1,6 +1,6 @@
-import { Router } from 'express';
+import { Router } from "express";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { Tool } from '../types/index.js';
+import { Tool } from "../types/index.js";
 
 const router = Router();
 
@@ -8,23 +8,23 @@ const router = Router();
 const tools: Tool[] = [];
 
 // List devices endpoint
-router.get('/devices', async (req, res) => {
+router.get("/devices", async (req, res) => {
   try {
     // Get token from Authorization header
-        const token = req.headers.authorization?.replace('Bearer ', '');
+    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'
+        message: "Unauthorized - Invalid token",
       });
     }
 
-        const tool = tools.find(t => t.name === 'list_devices');
+    const tool = tools.find((t) => t.name === "list_devices");
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
       });
     }
 
@@ -33,41 +33,43 @@ router.get('/devices', async (req, res) => {
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });
 
 // Control device endpoint
-router.post('/control', async (req, res) => {
+router.post("/control", async (req, res) => {
   try {
     // Get token from Authorization header
-        const token = req.headers.authorization?.replace('Bearer ', '');
+    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'
+        message: "Unauthorized - Invalid token",
       });
     }
 
-        const tool = tools.find(t => t.name === 'control');
+    const tool = tools.find((t) => t.name === "control");
     if (!tool) {
       return res.status(404).json({
         success: false,
-                message: 'Tool not found'
+        message: "Tool not found",
       });
     }
 
     const result = await tool.execute({
       ...req.body,
-            token
+      token,
     });
     res.json(result);
   } catch (error) {
     res.status(500).json({
       success: false,
-            message: error instanceof Error ? error.message : 'Unknown error occurred'
+      message:
+        error instanceof Error ? error.message : "Unknown error occurred",
     });
   }
 });

src/schemas.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 
-
 export const DomainSchema = z.enum([
   "light",
   "climate",
@@ -14,7 +13,7 @@ export const DomainSchema = z.enum([
   "vacuum",
   "scene",
   "script",
-    "camera"
+  "camera",
 ]);
 
 // Generic list request schema
@@ -58,12 +57,10 @@ export const AlarmSchema = z.object({
   state_attributes: AlarmAttributesSchema,
 });
 
-
 export const ListAlarmsResponseSchema = z.object({
   alarms: z.array(AlarmSchema),
 });
 
-
 // Devices
 
 export const DeviceSchema = z.object({
@@ -87,12 +84,12 @@ export const DeviceSchema = z.object({
   modified_at: z.number(),
   identifiers: z.array(z.any()),
   labels: z.array(z.string()),
-    serial_number: z.string().optional()
+  serial_number: z.string().optional(),
 });
 
 export const ListDevicesResponseSchema = z.object({
   _meta: z.object({}).optional(),
-    devices: z.array(DeviceSchema)
+  devices: z.array(DeviceSchema),
 });
 
 // Media Player

src/schemas/hass.ts

@@ -1,5 +1,5 @@
-import { JSONSchemaType } from 'ajv';
+import { JSONSchemaType } from "ajv";
-import { Entity, StateChangedEvent } from '../types/hass.js';
+import { Entity, StateChangedEvent } from "../types/hass.js";
 
 // Define base types for automation components
 type TriggerType = {
@@ -31,14 +31,22 @@ type ActionType = {
 type AutomationType = {
   alias: string;
   description?: string | null;
-    mode?: ('single' | 'parallel' | 'queued' | 'restart') | null;
+  mode?: ("single" | "parallel" | "queued" | "restart") | null;
   trigger: TriggerType[];
   condition?: ConditionType[] | null;
   action: ActionType[];
 };
 
 type DeviceControlType = {
-    domain: 'light' | 'switch' | 'climate' | 'cover' | 'fan' | 'scene' | 'script' | 'media_player';
+  domain:
+    | "light"
+    | "switch"
+    | "climate"
+    | "cover"
+    | "fan"
+    | "scene"
+    | "script"
+    | "media_player";
   command: string;
   entity_id: string | string[];
   parameters?: Record<string, any> | null;
@@ -75,194 +83,210 @@ export interface Config {
 
 // Define base schemas
 const contextSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        id: { type: 'string' },
+    id: { type: "string" },
-        parent_id: { type: 'string', nullable: true },
+    parent_id: { type: "string", nullable: true },
-        user_id: { type: 'string', nullable: true }
+    user_id: { type: "string", nullable: true },
   },
-    required: ['id', 'parent_id', 'user_id'],
+  required: ["id", "parent_id", "user_id"],
-    additionalProperties: false
+  additionalProperties: false,
 } as const;
 
 // Entity schema
 export const entitySchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        entity_id: { type: 'string' },
+    entity_id: { type: "string" },
-        state: { type: 'string' },
+    state: { type: "string" },
     attributes: {
-            type: 'object',
+      type: "object",
-            additionalProperties: true
+      additionalProperties: true,
     },
-        last_changed: { type: 'string' },
+    last_changed: { type: "string" },
-        last_updated: { type: 'string' },
+    last_updated: { type: "string" },
-        context: contextSchema
+    context: contextSchema,
   },
-    required: ['entity_id', 'state', 'attributes', 'last_changed', 'last_updated', 'context'],
+  required: [
-    additionalProperties: false
+    "entity_id",
+    "state",
+    "attributes",
+    "last_changed",
+    "last_updated",
+    "context",
+  ],
+  additionalProperties: false,
 } as const;
 
 // Service schema
 export const serviceSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        name: { type: 'string' },
+    name: { type: "string" },
-        description: { type: 'string' },
+    description: { type: "string" },
     target: {
-            type: 'object',
+      type: "object",
       nullable: true,
       properties: {
-                entity: { type: 'array', items: { type: 'string' }, nullable: true },
+        entity: { type: "array", items: { type: "string" }, nullable: true },
-                device: { type: 'array', items: { type: 'string' }, nullable: true },
+        device: { type: "array", items: { type: "string" }, nullable: true },
-                area: { type: 'array', items: { type: 'string' }, nullable: true }
+        area: { type: "array", items: { type: "string" }, nullable: true },
       },
       required: [],
-            additionalProperties: false
+      additionalProperties: false,
     },
     fields: {
-            type: 'object',
+      type: "object",
-            additionalProperties: true
+      additionalProperties: true,
-        }
     },
-    required: ['name', 'description', 'fields'],
+  },
-    additionalProperties: false
+  required: ["name", "description", "fields"],
+  additionalProperties: false,
 } as const;
 
 // Define the trigger schema without type assertion
 export const triggerSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        platform: { type: 'string' },
+    platform: { type: "string" },
-        event: { type: 'string', nullable: true },
+    event: { type: "string", nullable: true },
-        entity_id: { type: 'string', nullable: true },
+    entity_id: { type: "string", nullable: true },
-        to: { type: 'string', nullable: true },
+    to: { type: "string", nullable: true },
-        from: { type: 'string', nullable: true },
+    from: { type: "string", nullable: true },
-        offset: { type: 'string', nullable: true }
+    offset: { type: "string", nullable: true },
   },
-    required: ['platform'],
+  required: ["platform"],
-    additionalProperties: true
+  additionalProperties: true,
 };
 
 // Define the automation schema
 export const automationSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        alias: { type: 'string' },
+    alias: { type: "string" },
-        description: { type: 'string', nullable: true },
+    description: { type: "string", nullable: true },
     mode: {
-            type: 'string',
+      type: "string",
-            enum: ['single', 'parallel', 'queued', 'restart'],
+      enum: ["single", "parallel", "queued", "restart"],
-            nullable: true
+      nullable: true,
     },
     trigger: {
-            type: 'array',
+      type: "array",
-            items: triggerSchema
+      items: triggerSchema,
     },
     condition: {
-            type: 'array',
+      type: "array",
       items: {
-                type: 'object',
+        type: "object",
-                additionalProperties: true
+        additionalProperties: true,
       },
-            nullable: true
+      nullable: true,
     },
     action: {
-            type: 'array',
+      type: "array",
       items: {
-                type: 'object',
+        type: "object",
-                additionalProperties: true
+        additionalProperties: true,
-            }
-        }
       },
-    required: ['alias', 'trigger', 'action'],
+    },
-    additionalProperties: false
+  },
+  required: ["alias", "trigger", "action"],
+  additionalProperties: false,
 };
 
 export const deviceControlSchema: JSONSchemaType<DeviceControlType> = {
-    type: 'object',
+  type: "object",
   properties: {
     domain: {
-            type: 'string',
+      type: "string",
-            enum: ['light', 'switch', 'climate', 'cover', 'fan', 'scene', 'script', 'media_player']
+      enum: [
+        "light",
+        "switch",
+        "climate",
+        "cover",
+        "fan",
+        "scene",
+        "script",
+        "media_player",
+      ],
     },
-        command: { type: 'string' },
+    command: { type: "string" },
     entity_id: {
       anyOf: [
-                { type: 'string' },
+        { type: "string" },
         {
-                    type: 'array',
+          type: "array",
-                    items: { type: 'string' }
+          items: { type: "string" },
-                }
+        },
-            ]
+      ],
     },
     parameters: {
-            type: 'object',
+      type: "object",
       nullable: true,
-            additionalProperties: true
+      additionalProperties: true,
-        }
     },
-    required: ['domain', 'command', 'entity_id'],
+  },
-    additionalProperties: false
+  required: ["domain", "command", "entity_id"],
+  additionalProperties: false,
 };
 
 // State changed event schema
 export const stateChangedEventSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        event_type: { type: 'string', const: 'state_changed' },
+    event_type: { type: "string", const: "state_changed" },
     data: {
-            type: 'object',
+      type: "object",
       properties: {
-                entity_id: { type: 'string' },
+        entity_id: { type: "string" },
         new_state: { ...entitySchema, nullable: true },
-                old_state: { ...entitySchema, nullable: true }
+        old_state: { ...entitySchema, nullable: true },
       },
-            required: ['entity_id', 'new_state', 'old_state'],
+      required: ["entity_id", "new_state", "old_state"],
-            additionalProperties: false
+      additionalProperties: false,
     },
-        origin: { type: 'string' },
+    origin: { type: "string" },
-        time_fired: { type: 'string' },
+    time_fired: { type: "string" },
-        context: contextSchema
+    context: contextSchema,
   },
-    required: ['event_type', 'data', 'origin', 'time_fired', 'context'],
+  required: ["event_type", "data", "origin", "time_fired", "context"],
-    additionalProperties: false
+  additionalProperties: false,
 } as const;
 
 // Config schema
 export const configSchema = {
-    type: 'object',
+  type: "object",
   properties: {
-        components: { type: 'array', items: { type: 'string' } },
+    components: { type: "array", items: { type: "string" } },
-        config_dir: { type: 'string' },
+    config_dir: { type: "string" },
-        elevation: { type: 'number' },
+    elevation: { type: "number" },
-        latitude: { type: 'number' },
+    latitude: { type: "number" },
-        longitude: { type: 'number' },
+    longitude: { type: "number" },
-        location_name: { type: 'string' },
+    location_name: { type: "string" },
-        time_zone: { type: 'string' },
+    time_zone: { type: "string" },
     unit_system: {
-            type: 'object',
+      type: "object",
       properties: {
-                length: { type: 'string' },
+        length: { type: "string" },
-                mass: { type: 'string' },
+        mass: { type: "string" },
-                temperature: { type: 'string' },
+        temperature: { type: "string" },
-                volume: { type: 'string' }
+        volume: { type: "string" },
       },
-            required: ['length', 'mass', 'temperature', 'volume'],
+      required: ["length", "mass", "temperature", "volume"],
-            additionalProperties: false
+      additionalProperties: false,
     },
-        version: { type: 'string' }
+    version: { type: "string" },
   },
   required: [
-        'components',
+    "components",
-        'config_dir',
+    "config_dir",
-        'elevation',
+    "elevation",
-        'latitude',
+    "latitude",
-        'longitude',
+    "longitude",
-        'location_name',
+    "location_name",
-        'time_zone',
+    "time_zone",
-        'unit_system',
+    "unit_system",
-        'version'
+    "version",
   ],
-    additionalProperties: false
+  additionalProperties: false,
 } as const;

src/security/__tests__/security.test.ts

@@ -1,11 +1,11 @@
-import { TokenManager } from '../index';
+import { TokenManager } from "../index";
-import { SECURITY_CONFIG } from '../../config/security.config';
+import { SECURITY_CONFIG } from "../../config/security.config";
-import jwt from 'jsonwebtoken';
+import jwt from "jsonwebtoken";
-import { jest } from '@jest/globals';
+import { jest } from "@jest/globals";
 
-describe('TokenManager', () => {
+describe("TokenManager", () => {
-    const validSecret = 'test_secret_key_that_is_at_least_32_chars_long';
+  const validSecret = "test_secret_key_that_is_at_least_32_chars_long";
-    const testIp = '127.0.0.1';
+  const testIp = "127.0.0.1";
 
   beforeEach(() => {
     process.env.JWT_SECRET = validSecret;
@@ -16,70 +16,74 @@ describe('TokenManager', () => {
     delete process.env.JWT_SECRET;
   });
 
-    describe('Token Validation', () => {
+  describe("Token Validation", () => {
-        it('should validate a properly formatted token', () => {
+    it("should validate a properly formatted token", () => {
-            const payload = { userId: '123', role: 'user' };
+      const payload = { userId: "123", role: "user" };
       const token = jwt.sign(payload, validSecret);
       const result = TokenManager.validateToken(token, testIp);
       expect(result.valid).toBe(true);
       expect(result.error).toBeUndefined();
     });
 
-        it('should reject an invalid token', () => {
+    it("should reject an invalid token", () => {
-            const result = TokenManager.validateToken('invalid_token', testIp);
+      const result = TokenManager.validateToken("invalid_token", testIp);
       expect(result.valid).toBe(false);
-            expect(result.error).toBe('Token length below minimum requirement');
+      expect(result.error).toBe("Token length below minimum requirement");
     });
 
-        it('should reject a token that is too short', () => {
+    it("should reject a token that is too short", () => {
-            const result = TokenManager.validateToken('short', testIp);
+      const result = TokenManager.validateToken("short", testIp);
       expect(result.valid).toBe(false);
-            expect(result.error).toBe('Token length below minimum requirement');
+      expect(result.error).toBe("Token length below minimum requirement");
     });
 
-        it('should reject an expired token', () => {
+    it("should reject an expired token", () => {
       const now = Math.floor(Date.now() / 1000);
       const payload = {
-                userId: '123',
+        userId: "123",
-                role: 'user',
+        role: "user",
         iat: now - 7200, // 2 hours ago
-                exp: now - 3600   // expired 1 hour ago
+        exp: now - 3600, // expired 1 hour ago
       };
       const token = jwt.sign(payload, validSecret);
       const result = TokenManager.validateToken(token, testIp);
       expect(result.valid).toBe(false);
-            expect(result.error).toBe('Token has expired');
+      expect(result.error).toBe("Token has expired");
     });
 
-        it('should implement rate limiting for failed attempts', async () => {
+    it("should implement rate limiting for failed attempts", async () => {
       // Simulate multiple failed attempts
       for (let i = 0; i < SECURITY_CONFIG.MAX_FAILED_ATTEMPTS; i++) {
-                const result = TokenManager.validateToken('invalid_token', testIp);
+        const result = TokenManager.validateToken("invalid_token", testIp);
         expect(result.valid).toBe(false);
       }
 
       // Next attempt should be blocked by rate limiting
-            const result = TokenManager.validateToken('invalid_token', testIp);
+      const result = TokenManager.validateToken("invalid_token", testIp);
       expect(result.valid).toBe(false);
-            expect(result.error).toBe('Too many failed attempts. Please try again later.');
+      expect(result.error).toBe(
+        "Too many failed attempts. Please try again later.",
+      );
 
       // Wait for rate limit to expire
-            await new Promise(resolve => setTimeout(resolve, SECURITY_CONFIG.LOCKOUT_DURATION + 100));
+      await new Promise((resolve) =>
+        setTimeout(resolve, SECURITY_CONFIG.LOCKOUT_DURATION + 100),
+      );
 
       // Should be able to try again
-            const validPayload = { userId: '123', role: 'user' };
+      const validPayload = { userId: "123", role: "user" };
       const validToken = jwt.sign(validPayload, validSecret);
       const finalResult = TokenManager.validateToken(validToken, testIp);
       expect(finalResult.valid).toBe(true);
     });
   });
 
-    describe('Token Generation', () => {
+  describe("Token Generation", () => {
-        it('should generate a valid JWT token', () => {
+    it("should generate a valid JWT token", () => {
-            const payload = { userId: '123', role: 'user' };
+      const payload = { userId: "123", role: "user" };
       const token = TokenManager.generateToken(payload);
       expect(token).toBeDefined();
-            expect(typeof token).toBe('string');
+      expect(typeof token).toBe("string");
 
       // Verify the token can be decoded
       const decoded = jwt.verify(token, validSecret) as any;
@@ -87,47 +91,57 @@ describe('TokenManager', () => {
       expect(decoded.role).toBe(payload.role);
     });
 
-        it('should include required claims in generated tokens', () => {
+    it("should include required claims in generated tokens", () => {
-            const payload = { userId: '123' };
+      const payload = { userId: "123" };
       const token = TokenManager.generateToken(payload);
       const decoded = jwt.verify(token, validSecret) as any;
 
       expect(decoded.iat).toBeDefined();
       expect(decoded.exp).toBeDefined();
       expect(decoded.exp - decoded.iat).toBe(
-                Math.floor(24 * 60 * 60) // 24 hours in seconds
+        Math.floor(24 * 60 * 60), // 24 hours in seconds
       );
     });
 
-        it('should throw error when JWT secret is not configured', () => {
+    it("should throw error when JWT secret is not configured", () => {
       delete process.env.JWT_SECRET;
-            const payload = { userId: '123' };
+      const payload = { userId: "123" };
-            expect(() => TokenManager.generateToken(payload)).toThrow('JWT secret not configured');
+      expect(() => TokenManager.generateToken(payload)).toThrow(
+        "JWT secret not configured",
+      );
     });
   });
 
-    describe('Token Encryption', () => {
+  describe("Token Encryption", () => {
-        const encryptionKey = 'encryption_key_that_is_at_least_32_chars_long';
+    const encryptionKey = "encryption_key_that_is_at_least_32_chars_long";
 
-        it('should encrypt and decrypt a token successfully', () => {
+    it("should encrypt and decrypt a token successfully", () => {
-            const originalToken = 'test_token_to_encrypt';
+      const originalToken = "test_token_to_encrypt";
       const encrypted = TokenManager.encryptToken(originalToken, encryptionKey);
       const decrypted = TokenManager.decryptToken(encrypted, encryptionKey);
       expect(decrypted).toBe(originalToken);
     });
 
-        it('should throw error for invalid encryption inputs', () => {
+    it("should throw error for invalid encryption inputs", () => {
-            expect(() => TokenManager.encryptToken('', encryptionKey)).toThrow('Invalid token');
+      expect(() => TokenManager.encryptToken("", encryptionKey)).toThrow(
-            expect(() => TokenManager.encryptToken('valid_token', '')).toThrow('Invalid encryption key');
+        "Invalid token",
+      );
+      expect(() => TokenManager.encryptToken("valid_token", "")).toThrow(
+        "Invalid encryption key",
+      );
     });
 
-        it('should throw error for invalid decryption inputs', () => {
+    it("should throw error for invalid decryption inputs", () => {
-            expect(() => TokenManager.decryptToken('', encryptionKey)).toThrow('Invalid encrypted token');
+      expect(() => TokenManager.decryptToken("", encryptionKey)).toThrow(
-            expect(() => TokenManager.decryptToken('invalid:format', encryptionKey)).toThrow('Invalid encrypted token format');
+        "Invalid encrypted token",
+      );
+      expect(() =>
+        TokenManager.decryptToken("invalid:format", encryptionKey),
+      ).toThrow("Invalid encrypted token format");
     });
 
-        it('should generate different ciphertexts for same plaintext', () => {
+    it("should generate different ciphertexts for same plaintext", () => {
-            const token = 'test_token';
+      const token = "test_token";
       const encrypted1 = TokenManager.encryptToken(token, encryptionKey);
       const encrypted2 = TokenManager.encryptToken(token, encryptionKey);
       expect(encrypted1).not.toBe(encrypted2);

src/security/index.ts

@@ -1,9 +1,9 @@
-import crypto from 'crypto';
+import crypto from "crypto";
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
-import rateLimit from 'express-rate-limit';
+import rateLimit from "express-rate-limit";
-import helmet from 'helmet';
+import helmet from "helmet";
-import { HelmetOptions } from 'helmet';
+import { HelmetOptions } from "helmet";
-import jwt from 'jsonwebtoken';
+import jwt from "jsonwebtoken";
 
 // Security configuration
 const RATE_LIMIT_WINDOW = 15 * 60 * 1000; // 15 minutes
@@ -14,7 +14,7 @@ const TOKEN_EXPIRY = 24 * 60 * 60 * 1000; // 24 hours
 export const rateLimiter = rateLimit({
   windowMs: RATE_LIMIT_WINDOW,
   max: RATE_LIMIT_MAX,
-    message: 'Too many requests from this IP, please try again later'
+  message: "Too many requests from this IP, please try again later",
 });
 
 // Security configuration
@@ -25,9 +25,9 @@ const helmetConfig: HelmetOptions = {
       defaultSrc: ["'self'"],
       scriptSrc: ["'self'", "'unsafe-inline'"],
       styleSrc: ["'self'", "'unsafe-inline'"],
-            imgSrc: ["'self'", 'data:', 'https:'],
+      imgSrc: ["'self'", "data:", "https:"],
-            connectSrc: ["'self'", 'wss:', 'https:']
+      connectSrc: ["'self'", "wss:", "https:"],
-        }
+    },
   },
   dnsPrefetchControl: true,
   frameguard: true,
@@ -36,14 +36,14 @@ const helmetConfig: HelmetOptions = {
   ieNoOpen: true,
   noSniff: true,
   referrerPolicy: {
-        policy: ['no-referrer', 'strict-origin-when-cross-origin']
+    policy: ["no-referrer", "strict-origin-when-cross-origin"],
-    }
+  },
 };
 
 // Security headers middleware
 export const securityHeaders = helmet(helmetConfig);
 
-const ALGORITHM = 'aes-256-gcm';
+const ALGORITHM = "aes-256-gcm";
 const IV_LENGTH = 16;
 const AUTH_TAG_LENGTH = 16;
 
@@ -57,18 +57,21 @@ const SECURITY_CONFIG = {
 };
 
 // Track failed authentication attempts
-const failedAttempts = new Map<string, { count: number; lastAttempt: number }>();
+const failedAttempts = new Map<
+  string,
+  { count: number; lastAttempt: number }
+>();
 
 export class TokenManager {
   /**
    * Encrypts a token using AES-256-GCM
    */
   static encryptToken(token: string, key: string): string {
-        if (!token || typeof token !== 'string') {
+    if (!token || typeof token !== "string") {
-            throw new Error('Invalid token');
+      throw new Error("Invalid token");
     }
-        if (!key || typeof key !== 'string' || key.length < 32) {
+    if (!key || typeof key !== "string" || key.length < 32) {
-            throw new Error('Invalid encryption key');
+      throw new Error("Invalid encryption key");
     }
 
     try {
@@ -76,15 +79,15 @@ export class TokenManager {
       const cipher = crypto.createCipheriv(ALGORITHM, key.slice(0, 32), iv);
 
       const encrypted = Buffer.concat([
-                cipher.update(token, 'utf8'),
+        cipher.update(token, "utf8"),
-                cipher.final()
+        cipher.final(),
       ]);
       const tag = cipher.getAuthTag();
 
       // Format: algorithm:iv:tag:encrypted
-            return `${ALGORITHM}:${iv.toString('base64')}:${tag.toString('base64')}:${encrypted.toString('base64')}`;
+      return `${ALGORITHM}:${iv.toString("base64")}:${tag.toString("base64")}:${encrypted.toString("base64")}`;
     } catch (error) {
-            throw new Error('Failed to encrypt token');
+      throw new Error("Failed to encrypt token");
     }
   }
 
@@ -92,83 +95,98 @@ export class TokenManager {
    * Decrypts a token using AES-256-GCM
    */
   static decryptToken(encryptedToken: string, key: string): string {
-        if (!encryptedToken || typeof encryptedToken !== 'string') {
+    if (!encryptedToken || typeof encryptedToken !== "string") {
-            throw new Error('Invalid encrypted token');
+      throw new Error("Invalid encrypted token");
     }
-        if (!key || typeof key !== 'string' || key.length < 32) {
+    if (!key || typeof key !== "string" || key.length < 32) {
-            throw new Error('Invalid encryption key');
+      throw new Error("Invalid encryption key");
     }
 
     try {
-            const [algorithm, ivBase64, tagBase64, encryptedBase64] = encryptedToken.split(':');
+      const [algorithm, ivBase64, tagBase64, encryptedBase64] =
+        encryptedToken.split(":");
 
-            if (algorithm !== ALGORITHM || !ivBase64 || !tagBase64 || !encryptedBase64) {
+      if (
-                throw new Error('Invalid encrypted token format');
+        algorithm !== ALGORITHM ||
+        !ivBase64 ||
+        !tagBase64 ||
+        !encryptedBase64
+      ) {
+        throw new Error("Invalid encrypted token format");
       }
 
-            const iv = Buffer.from(ivBase64, 'base64');
+      const iv = Buffer.from(ivBase64, "base64");
-            const tag = Buffer.from(tagBase64, 'base64');
+      const tag = Buffer.from(tagBase64, "base64");
-            const encrypted = Buffer.from(encryptedBase64, 'base64');
+      const encrypted = Buffer.from(encryptedBase64, "base64");
 
       const decipher = crypto.createDecipheriv(ALGORITHM, key.slice(0, 32), iv);
       decipher.setAuthTag(tag);
 
       return Buffer.concat([
         decipher.update(encrypted),
-                decipher.final()
+        decipher.final(),
-            ]).toString('utf8');
+      ]).toString("utf8");
     } catch (error) {
-            if (error instanceof Error && error.message === 'Invalid encrypted token format') {
+      if (
+        error instanceof Error &&
+        error.message === "Invalid encrypted token format"
+      ) {
         throw error;
       }
-            throw new Error('Invalid encrypted token');
+      throw new Error("Invalid encrypted token");
     }
   }
 
   /**
    * Validates a JWT token with enhanced security checks
    */
-    static validateToken(token: string | undefined | null, ip?: string): { valid: boolean; error?: string } {
+  static validateToken(
+    token: string | undefined | null,
+    ip?: string,
+  ): { valid: boolean; error?: string } {
     // Check basic token format
-        if (!token || typeof token !== 'string') {
+    if (!token || typeof token !== "string") {
-            return { valid: false, error: 'Invalid token format' };
+      return { valid: false, error: "Invalid token format" };
     }
 
     // Check for token length
     if (token.length < SECURITY_CONFIG.MIN_TOKEN_LENGTH) {
       if (ip) this.recordFailedAttempt(ip);
-            return { valid: false, error: 'Token length below minimum requirement' };
+      return { valid: false, error: "Token length below minimum requirement" };
     }
 
     // Check for rate limiting
     if (ip && this.isRateLimited(ip)) {
-            return { valid: false, error: 'Too many failed attempts. Please try again later.' };
+      return {
+        valid: false,
+        error: "Too many failed attempts. Please try again later.",
+      };
     }
 
     // Get JWT secret
     const secret = process.env.JWT_SECRET;
     if (!secret) {
-            return { valid: false, error: 'JWT secret not configured' };
+      return { valid: false, error: "JWT secret not configured" };
     }
 
     try {
       // Verify token signature and decode
       const decoded = jwt.verify(token, secret, {
-                algorithms: ['HS256'],
+        algorithms: ["HS256"],
         clockTolerance: 0, // No clock skew tolerance
-                ignoreExpiration: false // Always check expiration
+        ignoreExpiration: false, // Always check expiration
       }) as jwt.JwtPayload;
 
       // Verify token structure
-            if (!decoded || typeof decoded !== 'object') {
+      if (!decoded || typeof decoded !== "object") {
         if (ip) this.recordFailedAttempt(ip);
-                return { valid: false, error: 'Invalid token structure' };
+        return { valid: false, error: "Invalid token structure" };
       }
 
       // Check required claims
       if (!decoded.exp || !decoded.iat) {
         if (ip) this.recordFailedAttempt(ip);
-                return { valid: false, error: 'Token missing required claims' };
+        return { valid: false, error: "Token missing required claims" };
       }
 
       const now = Math.floor(Date.now() / 1000);
@@ -176,14 +194,14 @@ export class TokenManager {
       // Check expiration
       if (decoded.exp <= now) {
         if (ip) this.recordFailedAttempt(ip);
-                return { valid: false, error: 'Token has expired' };
+        return { valid: false, error: "Token has expired" };
       }
 
       // Check token age
       const tokenAge = (now - decoded.iat) * 1000;
       if (tokenAge > SECURITY_CONFIG.MAX_TOKEN_AGE) {
         if (ip) this.recordFailedAttempt(ip);
-                return { valid: false, error: 'Token exceeds maximum age limit' };
+        return { valid: false, error: "Token exceeds maximum age limit" };
       }
 
       // Reset failed attempts on successful validation
@@ -195,12 +213,12 @@ export class TokenManager {
     } catch (error) {
       if (ip) this.recordFailedAttempt(ip);
       if (error instanceof jwt.TokenExpiredError) {
-                return { valid: false, error: 'Token has expired' };
+        return { valid: false, error: "Token has expired" };
       }
       if (error instanceof jwt.JsonWebTokenError) {
-                return { valid: false, error: 'Invalid token signature' };
+        return { valid: false, error: "Invalid token signature" };
       }
-            return { valid: false, error: 'Token validation failed' };
+      return { valid: false, error: "Token validation failed" };
     }
   }
 
@@ -210,7 +228,10 @@ export class TokenManager {
   private static recordFailedAttempt(ip?: string): void {
     if (!ip) return;
 
-        const attempt = failedAttempts.get(ip) || { count: 0, lastAttempt: Date.now() };
+    const attempt = failedAttempts.get(ip) || {
+      count: 0,
+      lastAttempt: Date.now(),
+    };
     attempt.count++;
     attempt.lastAttempt = Date.now();
     failedAttempts.set(ip, attempt);
@@ -238,7 +259,7 @@ export class TokenManager {
   static generateToken(payload: Record<string, any>): string {
     const secret = process.env.JWT_SECRET;
     if (!secret) {
-            throw new Error('JWT secret not configured');
+      throw new Error("JWT secret not configured");
     }
 
     // Add required claims
@@ -246,78 +267,82 @@ export class TokenManager {
     const tokenPayload = {
       ...payload,
       iat: now,
-            exp: now + Math.floor(TOKEN_EXPIRY / 1000)
+      exp: now + Math.floor(TOKEN_EXPIRY / 1000),
     };
 
     return jwt.sign(tokenPayload, secret, {
-            algorithm: 'HS256'
+      algorithm: "HS256",
     });
   }
 }
 
 // Request validation middleware
-export function validateRequest(req: Request, res: Response, next: NextFunction): Response | void {
+export function validateRequest(
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): Response | void {
   // Skip validation for health and MCP schema endpoints
-    if (req.path === '/health' || req.path === '/mcp') {
+  if (req.path === "/health" || req.path === "/mcp") {
     return next();
   }
 
   // Validate content type for non-GET requests
-    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+  if (["POST", "PUT", "PATCH"].includes(req.method)) {
-        const contentType = req.headers['content-type'] || '';
+    const contentType = req.headers["content-type"] || "";
-        if (!contentType.toLowerCase().includes('application/json')) {
+    if (!contentType.toLowerCase().includes("application/json")) {
       return res.status(415).json({
         success: false,
-                message: 'Unsupported Media Type',
+        message: "Unsupported Media Type",
-                error: 'Content-Type must be application/json',
+        error: "Content-Type must be application/json",
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
   }
 
   // Validate authorization header
   const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: 'Missing or invalid authorization header',
+      error: "Missing or invalid authorization header",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
   // Validate token
-    const token = authHeader.replace('Bearer ', '');
+  const token = authHeader.replace("Bearer ", "");
   const validationResult = TokenManager.validateToken(token, req.ip);
   if (!validationResult.valid) {
     return res.status(401).json({
       success: false,
-            message: 'Unauthorized',
+      message: "Unauthorized",
-            error: validationResult.error || 'Invalid token',
+      error: validationResult.error || "Invalid token",
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
   // Validate request body for non-GET requests
-    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+  if (["POST", "PUT", "PATCH"].includes(req.method)) {
-        if (!req.body || typeof req.body !== 'object' || Array.isArray(req.body)) {
+    if (!req.body || typeof req.body !== "object" || Array.isArray(req.body)) {
       return res.status(400).json({
         success: false,
-                message: 'Bad Request',
+        message: "Bad Request",
-                error: 'Invalid request body structure',
+        error: "Invalid request body structure",
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
 
     // Check request body size
-        const contentLength = parseInt(req.headers['content-length'] || '0', 10);
+    const contentLength = parseInt(req.headers["content-length"] || "0", 10);
     const maxSize = 1024 * 1024; // 1MB limit
     if (contentLength > maxSize) {
       return res.status(413).json({
         success: false,
-                message: 'Payload Too Large',
+        message: "Payload Too Large",
         error: `Request body must not exceed ${maxSize} bytes`,
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
   }
@@ -332,20 +357,20 @@ export function sanitizeInput(req: Request, res: Response, next: NextFunction) {
   }
 
   function sanitizeValue(value: unknown): unknown {
-        if (typeof value === 'string') {
+    if (typeof value === "string") {
       // Remove HTML tags and scripts more thoroughly
       return value
-                .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '') // Remove script tags and content
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "") // Remove script tags and content
-                .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')   // Remove style tags and content
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "") // Remove style tags and content
-                .replace(/<[^>]+>/g, '')                                            // Remove remaining HTML tags
+        .replace(/<[^>]+>/g, "") // Remove remaining HTML tags
-                .replace(/javascript:/gi, '')                                       // Remove javascript: protocol
+        .replace(/javascript:/gi, "") // Remove javascript: protocol
-                .replace(/on\w+\s*=\s*(?:".*?"|'.*?'|[^"'>\s]+)/gi, '')           // Remove event handlers
+        .replace(/on\w+\s*=\s*(?:".*?"|'.*?'|[^"'>\s]+)/gi, "") // Remove event handlers
         .trim();
     }
     if (Array.isArray(value)) {
-            return value.map(item => sanitizeValue(item));
+      return value.map((item) => sanitizeValue(item));
     }
-        if (typeof value === 'object' && value !== null) {
+    if (typeof value === "object" && value !== null) {
       const sanitized: Record<string, unknown> = {};
       for (const [key, val] of Object.entries(value)) {
         sanitized[key] = sanitizeValue(val);
@@ -360,11 +385,16 @@ export function sanitizeInput(req: Request, res: Response, next: NextFunction) {
 }
 
 // Error handling middleware
-export function errorHandler(err: Error, req: Request, res: Response, next: NextFunction) {
+export function errorHandler(
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) {
   console.error(err.stack);
   res.status(500).json({
-        error: 'Internal Server Error',
+    error: "Internal Server Error",
-        message: process.env.NODE_ENV === 'development' ? err.message : undefined
+    message: process.env.NODE_ENV === "development" ? err.message : undefined,
   });
 }
 
@@ -373,9 +403,9 @@ export const securityMiddleware = [
   helmet(helmetConfig),
   rateLimit({
     windowMs: 15 * 60 * 1000,
-        max: 100
+    max: 100,
   }),
   validateRequest,
   sanitizeInput,
-    errorHandler
+  errorHandler,
 ];

src/security/middleware.test.ts

@@ -1,9 +1,9 @@
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction } from "express";
-import { validateRequest, sanitizeInput } from '../../src/security/middleware';
+import { validateRequest, sanitizeInput } from "../../src/security/middleware";
 
 type MockRequest = {
   headers: {
-        'content-type'?: string;
+    "content-type"?: string;
     authorization?: string;
   };
   body?: any;
@@ -16,7 +16,7 @@ type MockResponse = {
   setHeader: jest.MockInstance<MockResponse, [name: string, value: string]>;
 };
 
-describe('Security Middleware', () => {
+describe("Security Middleware", () => {
   let mockRequest: MockRequest;
   let mockResponse: MockResponse;
   let nextFunction: jest.Mock;
@@ -25,83 +25,117 @@ describe('Security Middleware', () => {
     mockRequest = {
       headers: {},
       body: {},
-            is: jest.fn<string | false | null, [string | string[]]>().mockReturnValue('json')
+      is: jest
+        .fn<string | false | null, [string | string[]]>()
+        .mockReturnValue("json"),
     };
 
     mockResponse = {
       status: jest.fn<MockResponse, [number]>().mockReturnThis(),
       json: jest.fn<MockResponse, [any]>().mockReturnThis(),
-            setHeader: jest.fn<MockResponse, [string, string]>().mockReturnThis()
+      setHeader: jest.fn<MockResponse, [string, string]>().mockReturnThis(),
     };
 
     nextFunction = jest.fn();
   });
 
-    describe('validateRequest', () => {
+  describe("validateRequest", () => {
-        it('should pass valid requests', () => {
+    it("should pass valid requests", () => {
-            mockRequest.headers.authorization = 'Bearer valid-token';
+      mockRequest.headers.authorization = "Bearer valid-token";
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      validateRequest(
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should reject requests without authorization header', () => {
+    it("should reject requests without authorization header", () => {
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      validateRequest(
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(401);
-            expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+      expect(mockResponse.json).toHaveBeenCalledWith(
-                error: expect.stringContaining('authorization')
+        expect.objectContaining({
-            }));
+          error: expect.stringContaining("authorization"),
+        }),
+      );
     });
 
-        it('should reject requests with invalid authorization format', () => {
+    it("should reject requests with invalid authorization format", () => {
-            mockRequest.headers.authorization = 'invalid-format';
+      mockRequest.headers.authorization = "invalid-format";
-            validateRequest(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      validateRequest(
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
       expect(mockResponse.status).toHaveBeenCalledWith(401);
-            expect(mockResponse.json).toHaveBeenCalledWith(expect.objectContaining({
+      expect(mockResponse.json).toHaveBeenCalledWith(
-                error: expect.stringContaining('Bearer')
+        expect.objectContaining({
-            }));
+          error: expect.stringContaining("Bearer"),
+        }),
+      );
     });
   });
 
-    describe('sanitizeInput', () => {
+  describe("sanitizeInput", () => {
-        it('should pass requests without body', () => {
+    it("should pass requests without body", () => {
       delete mockRequest.body;
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      sanitizeInput(
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should sanitize HTML in request body', () => {
+    it("should sanitize HTML in request body", () => {
       mockRequest.body = {
         text: '<script>alert("xss")</script>Hello',
         nested: {
-                    html: '<img src="x" onerror="alert(1)">World'
+          html: '<img src="x" onerror="alert(1)">World',
-                }
+        },
       };
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      sanitizeInput(
-            expect(mockRequest.body.text).toBe('Hello');
+        mockRequest as unknown as Request,
-            expect(mockRequest.body.nested.html).toBe('World');
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
+      expect(mockRequest.body.text).toBe("Hello");
+      expect(mockRequest.body.nested.html).toBe("World");
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should handle non-object bodies', () => {
+    it("should handle non-object bodies", () => {
-            mockRequest.body = '<p>text</p>';
+      mockRequest.body = "<p>text</p>";
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      sanitizeInput(
-            expect(mockRequest.body).toBe('text');
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
+      expect(mockRequest.body).toBe("text");
       expect(nextFunction).toHaveBeenCalled();
     });
 
-        it('should preserve non-string values', () => {
+    it("should preserve non-string values", () => {
       mockRequest.body = {
         number: 42,
         boolean: true,
         null: null,
-                array: [1, 2, 3]
+        array: [1, 2, 3],
       };
-            sanitizeInput(mockRequest as unknown as Request, mockResponse as unknown as Response, nextFunction);
+      sanitizeInput(
+        mockRequest as unknown as Request,
+        mockResponse as unknown as Response,
+        nextFunction,
+      );
       expect(mockRequest.body).toEqual({
         number: 42,
         boolean: true,
         null: null,
-                array: [1, 2, 3]
+        array: [1, 2, 3],
       });
       expect(nextFunction).toHaveBeenCalled();
     });

src/sse/__tests__/sse.security.test.ts

@@ -1,13 +1,23 @@
-import { SSEManager } from '../index';
+import { SSEManager } from "../index";
-import { TokenManager } from '../../security/index';
+import { TokenManager } from "../../security/index";
-import type { SSEClient } from '../types';
+import type { SSEClient } from "../types";
-import { describe, it, expect, beforeEach, afterEach, mock, Mock } from 'bun:test';
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  mock,
+  Mock,
+} from "bun:test";
 
-describe('SSE Security Features', () => {
+describe("SSE Security Features", () => {
-    const TEST_IP = '127.0.0.1';
+  const TEST_IP = "127.0.0.1";
-    const validToken = 'valid_token';
+  const validToken = "valid_token";
   let sseManager: SSEManager;
-    let validateTokenMock: Mock<(token: string, ip: string) => { valid: boolean; error?: string }>;
+  let validateTokenMock: Mock<
+    (token: string, ip: string) => { valid: boolean; error?: string }
+  >;
 
   beforeEach(() => {
     sseManager = new SSEManager({
@@ -15,13 +25,13 @@ describe('SSE Security Features', () => {
       rateLimit: {
         MAX_MESSAGES: 2,
         WINDOW_MS: 1000,
-                BURST_LIMIT: 1
+        BURST_LIMIT: 1,
-            }
+      },
     });
 
     validateTokenMock = mock((token: string) => ({
       valid: token === validToken,
-            error: token !== validToken ? 'Invalid token' : undefined
+      error: token !== validToken ? "Invalid token" : undefined,
     }));
     TokenManager.validateToken = validateTokenMock;
   });
@@ -30,19 +40,21 @@ describe('SSE Security Features', () => {
     validateTokenMock.mockReset();
   });
 
-    function createTestClient(id: string): Omit<SSEClient, 'authenticated' | 'subscriptions' | 'rateLimit'> {
+  function createTestClient(
+    id: string,
+  ): Omit<SSEClient, "authenticated" | "subscriptions" | "rateLimit"> {
     return {
       id,
       ip: TEST_IP,
       connectedAt: new Date(),
       connectionTime: Date.now(),
-            send: mock((data: string) => { })
+      send: mock((data: string) => {}),
     };
   }
 
-    describe('Client Authentication', () => {
+  describe("Client Authentication", () => {
-        it('should authenticate valid clients', () => {
+    it("should authenticate valid clients", () => {
-            const client = createTestClient('test-client-1');
+      const client = createTestClient("test-client-1");
       const result = sseManager.addClient(client, validToken);
 
       expect(result).toBeTruthy();
@@ -50,19 +62,19 @@ describe('SSE Security Features', () => {
       expect(result?.authenticated).toBe(true);
     });
 
-        it('should reject invalid tokens', () => {
+    it("should reject invalid tokens", () => {
-            const client = createTestClient('test-client-2');
+      const client = createTestClient("test-client-2");
-            const result = sseManager.addClient(client, 'invalid_token');
+      const result = sseManager.addClient(client, "invalid_token");
 
       expect(result).toBeNull();
-            expect(validateTokenMock).toHaveBeenCalledWith('invalid_token', TEST_IP);
+      expect(validateTokenMock).toHaveBeenCalledWith("invalid_token", TEST_IP);
     });
 
-        it('should enforce maximum client limit', () => {
+    it("should enforce maximum client limit", () => {
       // Add max number of clients
-            const client1 = createTestClient('test-client-0');
+      const client1 = createTestClient("test-client-0");
-            const client2 = createTestClient('test-client-1');
+      const client2 = createTestClient("test-client-1");
-            const client3 = createTestClient('test-client-2');
+      const client3 = createTestClient("test-client-2");
 
       expect(sseManager.addClient(client1, validToken)).toBeTruthy();
       expect(sseManager.addClient(client2, validToken)).toBeTruthy();
@@ -70,9 +82,9 @@ describe('SSE Security Features', () => {
     });
   });
 
-    describe('Client Management', () => {
+  describe("Client Management", () => {
-        it('should track client connections', () => {
+    it("should track client connections", () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       sseManager.addClient(client, validToken);
 
       const stats = sseManager.getStatistics();
@@ -80,83 +92,101 @@ describe('SSE Security Features', () => {
       expect(stats.authenticatedClients).toBe(1);
     });
 
-        it('should remove disconnected clients', () => {
+    it("should remove disconnected clients", () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       sseManager.addClient(client, validToken);
-            sseManager.removeClient('test-client');
+      sseManager.removeClient("test-client");
 
       const stats = sseManager.getStatistics();
       expect(stats.totalClients).toBe(0);
     });
 
-        it('should cleanup inactive clients', async () => {
+    it("should cleanup inactive clients", async () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       sseManager.addClient(client, validToken);
 
       // Wait for cleanup interval
-            await new Promise(resolve => setTimeout(resolve, 250));
+      await new Promise((resolve) => setTimeout(resolve, 250));
 
       const stats = sseManager.getStatistics();
       expect(stats.totalClients).toBe(0);
     });
   });
 
-    describe('Rate Limiting', () => {
+  describe("Rate Limiting", () => {
-        it('should enforce rate limits for message sending', () => {
+    it("should enforce rate limits for message sending", () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       const sseClient = sseManager.addClient(client, validToken);
       expect(sseClient).toBeTruthy();
 
       // Send messages up to the limit
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'first' } });
+      sseManager["sendToClient"](sseClient!, {
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'second' } });
+        type: "test",
+        data: { value: "first" },
+      });
+      sseManager["sendToClient"](sseClient!, {
+        type: "test",
+        data: { value: "second" },
+      });
 
       // Next message should be rate limited
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'overflow' } });
+      sseManager["sendToClient"](sseClient!, {
+        type: "test",
+        data: { value: "overflow" },
+      });
 
       const sendMock = client.send as Mock<(data: string) => void>;
       expect(sendMock.mock.calls.length).toBe(2);
     });
 
-        it('should reset rate limits after window expires', async () => {
+    it("should reset rate limits after window expires", async () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       const sseClient = sseManager.addClient(client, validToken);
       expect(sseClient).toBeTruthy();
 
       // Send messages up to the limit
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'first' } });
+      sseManager["sendToClient"](sseClient!, {
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'second' } });
+        type: "test",
+        data: { value: "first" },
+      });
+      sseManager["sendToClient"](sseClient!, {
+        type: "test",
+        data: { value: "second" },
+      });
 
       // Wait for rate limit window to expire
-            await new Promise(resolve => setTimeout(resolve, 1100));
+      await new Promise((resolve) => setTimeout(resolve, 1100));
 
       // Should be able to send messages again
-            sseManager['sendToClient'](sseClient!, { type: 'test', data: { value: 'new message' } });
+      sseManager["sendToClient"](sseClient!, {
+        type: "test",
+        data: { value: "new message" },
+      });
 
       const sendMock = client.send as Mock<(data: string) => void>;
       expect(sendMock.mock.calls.length).toBe(3);
     });
   });
 
-    describe('Event Broadcasting', () => {
+  describe("Event Broadcasting", () => {
-        it('should only send events to authenticated clients', () => {
+    it("should only send events to authenticated clients", () => {
-            const client1 = createTestClient('client1');
+      const client1 = createTestClient("client1");
-            const client2 = createTestClient('client2');
+      const client2 = createTestClient("client2");
 
       const sseClient1 = sseManager.addClient(client1, validToken);
-            const sseClient2 = sseManager.addClient(client2, 'invalid_token');
+      const sseClient2 = sseManager.addClient(client2, "invalid_token");
 
       expect(sseClient1).toBeTruthy();
       expect(sseClient2).toBeNull();
 
-            sseClient1!.subscriptions.add('event:test_event');
+      sseClient1!.subscriptions.add("event:test_event");
 
       const event = {
-                event_type: 'test_event',
+        event_type: "test_event",
-                data: { value: 'test' },
+        data: { value: "test" },
-                origin: 'test',
+        origin: "test",
         time_fired: new Date().toISOString(),
-                context: { id: 'test' }
+        context: { id: "test" },
       };
 
       sseManager.broadcastEvent(event);
@@ -168,29 +198,29 @@ describe('SSE Security Features', () => {
       expect(client2SendMock.mock.calls.length).toBe(0);
     });
 
-        it('should respect subscription filters', () => {
+    it("should respect subscription filters", () => {
-            const client = createTestClient('test-client');
+      const client = createTestClient("test-client");
       const sseClient = sseManager.addClient(client, validToken);
       expect(sseClient).toBeTruthy();
 
-            sseClient!.subscriptions.add('event:test_event');
+      sseClient!.subscriptions.add("event:test_event");
 
       // Send matching event
       sseManager.broadcastEvent({
-                event_type: 'test_event',
+        event_type: "test_event",
-                data: { value: 'test' },
+        data: { value: "test" },
-                origin: 'test',
+        origin: "test",
         time_fired: new Date().toISOString(),
-                context: { id: 'test' }
+        context: { id: "test" },
       });
 
       // Send non-matching event
       sseManager.broadcastEvent({
-                event_type: 'other_event',
+        event_type: "other_event",
-                data: { value: 'test' },
+        data: { value: "test" },
-                origin: 'test',
+        origin: "test",
         time_fired: new Date().toISOString(),
-                context: { id: 'test' }
+        context: { id: "test" },
       });
 
       const sendMock = client.send as Mock<(data: string) => void>;

src/sse/index.ts

@@ -1,6 +1,6 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
-import { HassEntity, HassEvent } from '../interfaces/hass.js';
+import { HassEntity, HassEvent } from "../interfaces/hass.js";
-import { TokenManager } from '../security/index.js';
+import { TokenManager } from "../security/index.js";
 
 // Constants
 const DEFAULT_MAX_CLIENTS = 1000;
@@ -10,7 +10,7 @@ const DEFAULT_MAX_CONNECTION_AGE = 24 * 60 * 60 * 1000; // 24 hours
 const DEFAULT_RATE_LIMIT = {
   MAX_MESSAGES: 100, // messages
   WINDOW_MS: 60000, // 1 minute
-    BURST_LIMIT: 10    // max messages per second
+  BURST_LIMIT: 10, // max messages per second
 };
 
 interface RateLimit {
@@ -53,34 +53,39 @@ export class SSEManager extends EventEmitter {
   private readonly maxConnectionAge: number;
   private readonly rateLimit: typeof DEFAULT_RATE_LIMIT;
 
-    constructor(options: {
+  constructor(
+    options: {
       maxClients?: number;
       pingInterval?: number;
       cleanupInterval?: number;
       maxConnectionAge?: number;
       rateLimit?: Partial<typeof DEFAULT_RATE_LIMIT>;
-    } = {}) {
+    } = {},
+  ) {
     super();
     this.maxClients = options.maxClients || DEFAULT_MAX_CLIENTS;
     this.pingInterval = options.pingInterval || DEFAULT_PING_INTERVAL;
     this.cleanupInterval = options.cleanupInterval || DEFAULT_CLEANUP_INTERVAL;
-        this.maxConnectionAge = options.maxConnectionAge || DEFAULT_MAX_CONNECTION_AGE;
+    this.maxConnectionAge =
+      options.maxConnectionAge || DEFAULT_MAX_CONNECTION_AGE;
     this.rateLimit = { ...DEFAULT_RATE_LIMIT, ...options.rateLimit };
 
-        console.log('Initializing SSE Manager...');
+    console.log("Initializing SSE Manager...");
     this.startMaintenanceTasks();
   }
 
   private startMaintenanceTasks(): void {
     // Send periodic pings to keep connections alive
     setInterval(() => {
-            this.clients.forEach(client => {
+      this.clients.forEach((client) => {
         if (!this.isRateLimited(client)) {
           try {
-                        client.send(JSON.stringify({
+            client.send(
-                            type: 'ping',
+              JSON.stringify({
-                            timestamp: new Date().toISOString()
+                type: "ping",
-                        }));
+                timestamp: new Date().toISOString(),
+              }),
+            );
             client.lastPingAt = new Date();
           } catch (error) {
             console.error(`Failed to ping client ${client.id}:`, error);
@@ -95,9 +100,14 @@ export class SSEManager extends EventEmitter {
       const now = Date.now();
       this.clients.forEach((client, clientId) => {
         const connectionAge = now - client.connectedAt.getTime();
-                const lastPingAge = client.lastPingAt ? now - client.lastPingAt.getTime() : 0;
+        const lastPingAge = client.lastPingAt
+          ? now - client.lastPingAt.getTime()
+          : 0;
 
-                if (connectionAge > this.maxConnectionAge || lastPingAge > this.pingInterval * 2) {
+        if (
+          connectionAge > this.maxConnectionAge ||
+          lastPingAge > this.pingInterval * 2
+        ) {
           console.log(`Removing inactive client ${clientId}`);
           this.removeClient(clientId);
         }
@@ -112,11 +122,16 @@ export class SSEManager extends EventEmitter {
     return SSEManager.instance;
   }
 
-    addClient(client: Omit<SSEClient, 'authenticated' | 'subscriptions' | 'rateLimit'>, token: string): SSEClient | null {
+  addClient(
+    client: Omit<SSEClient, "authenticated" | "subscriptions" | "rateLimit">,
+    token: string,
+  ): SSEClient | null {
     // Validate token
     const validationResult = TokenManager.validateToken(token, client.ip);
     if (!validationResult.valid) {
-            console.warn(`Invalid token for client ${client.id} from IP ${client.ip}: ${validationResult.error}`);
+      console.warn(
+        `Invalid token for client ${client.id} from IP ${client.ip}: ${validationResult.error}`,
+      );
       return null;
     }
 
@@ -136,8 +151,8 @@ export class SSEManager extends EventEmitter {
         count: 0,
         lastReset: Date.now(),
         burstCount: 0,
-                lastBurstReset: Date.now()
+        lastBurstReset: Date.now(),
-            }
+      },
     };
 
     this.clients.set(client.id, newClient);
@@ -189,9 +204,9 @@ export class SSEManager extends EventEmitter {
     if (this.clients.has(clientId)) {
       this.clients.delete(clientId);
       console.log(`SSE client disconnected: ${clientId}`);
-            this.emit('client_disconnected', {
+      this.emit("client_disconnected", {
         clientId,
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     }
   }
@@ -199,7 +214,9 @@ export class SSEManager extends EventEmitter {
   subscribeToEntity(clientId: string, entityId: string): void {
     const client = this.clients.get(clientId);
     if (!client?.authenticated) {
-            console.warn(`Unauthenticated client ${clientId} attempted to subscribe to entity: ${entityId}`);
+      console.warn(
+        `Unauthenticated client ${clientId} attempted to subscribe to entity: ${entityId}`,
+      );
       return;
     }
 
@@ -210,14 +227,14 @@ export class SSEManager extends EventEmitter {
     const currentState = this.entityStates.get(entityId);
     if (currentState && !this.isRateLimited(client)) {
       this.sendToClient(client, {
-                type: 'state_changed',
+        type: "state_changed",
         data: {
           entity_id: currentState.entity_id,
           state: currentState.state,
           attributes: currentState.attributes,
           last_changed: currentState.last_changed,
-                    last_updated: currentState.last_updated
+          last_updated: currentState.last_updated,
-                }
+        },
       });
     }
   }
@@ -225,7 +242,9 @@ export class SSEManager extends EventEmitter {
   subscribeToDomain(clientId: string, domain: string): void {
     const client = this.clients.get(clientId);
     if (!client?.authenticated) {
-            console.warn(`Unauthenticated client ${clientId} attempted to subscribe to domain: ${domain}`);
+      console.warn(
+        `Unauthenticated client ${clientId} attempted to subscribe to domain: ${domain}`,
+      );
       return;
     }
 
@@ -236,7 +255,9 @@ export class SSEManager extends EventEmitter {
   subscribeToEvent(clientId: string, eventType: string): void {
     const client = this.clients.get(clientId);
     if (!client?.authenticated) {
-            console.warn(`Unauthenticated client ${clientId} attempted to subscribe to event: ${eventType}`);
+      console.warn(
+        `Unauthenticated client ${clientId} attempted to subscribe to event: ${eventType}`,
+      );
       return;
     }
 
@@ -248,29 +269,29 @@ export class SSEManager extends EventEmitter {
     // Update stored state
     this.entityStates.set(entity.entity_id, entity);
 
-        const domain = entity.entity_id.split('.')[0];
+    const domain = entity.entity_id.split(".")[0];
     const message = {
-            type: 'state_changed',
+      type: "state_changed",
       data: {
         entity_id: entity.entity_id,
         state: entity.state,
         attributes: entity.attributes,
         last_changed: entity.last_changed,
-                last_updated: entity.last_updated
+        last_updated: entity.last_updated,
       },
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
 
     console.log(`Broadcasting state change for ${entity.entity_id}`);
 
     // Send to relevant subscribers only
-        this.clients.forEach(client => {
+    this.clients.forEach((client) => {
       if (!client.authenticated || this.isRateLimited(client)) return;
 
       if (
         client.subscriptions.has(`entity:${entity.entity_id}`) ||
         client.subscriptions.has(`domain:${domain}`) ||
-                client.subscriptions.has('event:state_changed')
+        client.subscriptions.has("event:state_changed")
       ) {
         this.sendToClient(client, message);
       }
@@ -284,13 +305,13 @@ export class SSEManager extends EventEmitter {
       origin: event.origin,
       time_fired: event.time_fired,
       context: event.context,
-            timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
 
     console.log(`Broadcasting event: ${event.event_type}`);
 
     // Send to relevant subscribers only
-        this.clients.forEach(client => {
+    this.clients.forEach((client) => {
       if (!client.authenticated || this.isRateLimited(client)) return;
 
       if (client.subscriptions.has(`event:${event.event_type}`)) {
@@ -302,7 +323,9 @@ export class SSEManager extends EventEmitter {
   private sendToClient(client: SSEClient, data: unknown): void {
     try {
       if (!client.authenticated) {
-                console.warn(`Attempted to send message to unauthenticated client ${client.id}`);
+        console.warn(
+          `Attempted to send message to unauthenticated client ${client.id}`,
+        );
         return;
       }
 
@@ -311,7 +334,7 @@ export class SSEManager extends EventEmitter {
         return;
       }
 
-            const message = typeof data === 'string' ? data : JSON.stringify(data);
+      const message = typeof data === "string" ? data : JSON.stringify(data);
       client.send(message);
       this.updateRateLimit(client);
     } catch (error) {
@@ -331,7 +354,7 @@ export class SSEManager extends EventEmitter {
     const subscriptionStats: { [key: string]: number } = {};
     let authenticatedClients = 0;
 
-        this.clients.forEach(client => {
+    this.clients.forEach((client) => {
       if (client.authenticated) {
         authenticatedClients++;
       }
@@ -344,10 +367,10 @@ export class SSEManager extends EventEmitter {
         subscriptionCount: client.subscriptions.size,
         connectionDuration: now - client.connectedAt.getTime(),
         messagesSent: client.rateLimit.count,
-                lastActivity: new Date(client.rateLimit.lastReset)
+        lastActivity: new Date(client.rateLimit.lastReset),
       });
 
-            client.subscriptions.forEach(sub => {
+      client.subscriptions.forEach((sub) => {
         subscriptionStats[sub] = (subscriptionStats[sub] || 0) + 1;
       });
     });
@@ -356,7 +379,7 @@ export class SSEManager extends EventEmitter {
       totalClients: this.clients.size,
       authenticatedClients,
       clientStats,
-            subscriptionStats
+      subscriptionStats,
     };
   }
 }

src/sse/types.ts

@@ -1,4 +1,4 @@
-import type { Mock } from 'bun:test';
+import type { Mock } from "bun:test";
 
 export interface SSEClient {
   id: string;
@@ -45,18 +45,23 @@ export interface SSEManagerConfig {
 export type MockSendFn = (data: string) => void;
 export type MockSend = Mock<MockSendFn>;
 
-export type ValidateTokenFn = (token: string, ip?: string) => { valid: boolean; error?: string };
+export type ValidateTokenFn = (
+  token: string,
+  ip?: string,
+) => { valid: boolean; error?: string };
 export type MockValidateToken = Mock<ValidateTokenFn>;
 
 // Type guard for mock functions
 export function isMockFunction(value: unknown): value is Mock<unknown> {
-    return typeof value === 'function' && 'mock' in value;
+  return typeof value === "function" && "mock" in value;
 }
 
 // Safe type assertion for mock objects
-export function asMockFunction<T extends (...args: any[]) => any>(value: unknown): Mock<T> {
+export function asMockFunction<T extends (...args: any[]) => any>(
+  value: unknown,
+): Mock<T> {
   if (!isMockFunction(value)) {
-        throw new Error('Value is not a mock function');
+    throw new Error("Value is not a mock function");
   }
   return value as Mock<T>;
 }

src/tools/addon.tool.ts

@@ -1,31 +1,54 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, AddonParams, HassAddonResponse, HassAddonInfoResponse } from '../types/index.js';
+import {
-import { APP_CONFIG } from '../config/app.config.js';
+  Tool,
+  AddonParams,
+  HassAddonResponse,
+  HassAddonInfoResponse,
+} from "../types/index.js";
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const addonTool: Tool = {
-    name: 'addon',
+  name: "addon",
-    description: 'Manage Home Assistant add-ons',
+  description: "Manage Home Assistant add-ons",
   parameters: z.object({
-        action: z.enum(['list', 'info', 'install', 'uninstall', 'start', 'stop', 'restart'])
+    action: z
-            .describe('Action to perform with add-on'),
+      .enum([
-        slug: z.string().optional().describe('Add-on slug (required for all actions except list)'),
+        "list",
-        version: z.string().optional().describe('Version to install (only for install action)'),
+        "info",
+        "install",
+        "uninstall",
+        "start",
+        "stop",
+        "restart",
+      ])
+      .describe("Action to perform with add-on"),
+    slug: z
+      .string()
+      .optional()
+      .describe("Add-on slug (required for all actions except list)"),
+    version: z
+      .string()
+      .optional()
+      .describe("Version to install (only for install action)"),
   }),
   execute: async (params: AddonParams) => {
     try {
-            if (params.action === 'list') {
+      if (params.action === "list") {
-                const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/hassio/store`, {
+        const response = await fetch(
+          `${APP_CONFIG.HASS_HOST}/api/hassio/store`,
+          {
             headers: {
               Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+              "Content-Type": "application/json",
             },
-                });
+          },
+        );
 
         if (!response.ok) {
           throw new Error(`Failed to fetch add-ons: ${response.statusText}`);
         }
 
-                const data = await response.json() as HassAddonResponse;
+        const data = (await response.json()) as HassAddonResponse;
         return {
           success: true,
           addons: data.data.addons.map((addon) => ({
@@ -40,39 +63,39 @@ export const addonTool: Tool = {
         };
       } else {
         if (!params.slug) {
-                    throw new Error('Add-on slug is required for this action');
+          throw new Error("Add-on slug is required for this action");
         }
 
-                let endpoint = '';
+        let endpoint = "";
-                let method = 'GET';
+        let method = "GET";
         const body: Record<string, any> = {};
 
         switch (params.action) {
-                    case 'info':
+          case "info":
             endpoint = `/api/hassio/addons/${params.slug}/info`;
             break;
-                    case 'install':
+          case "install":
             endpoint = `/api/hassio/addons/${params.slug}/install`;
-                        method = 'POST';
+            method = "POST";
             if (params.version) {
               body.version = params.version;
             }
             break;
-                    case 'uninstall':
+          case "uninstall":
             endpoint = `/api/hassio/addons/${params.slug}/uninstall`;
-                        method = 'POST';
+            method = "POST";
             break;
-                    case 'start':
+          case "start":
             endpoint = `/api/hassio/addons/${params.slug}/start`;
-                        method = 'POST';
+            method = "POST";
             break;
-                    case 'stop':
+          case "stop":
             endpoint = `/api/hassio/addons/${params.slug}/stop`;
-                        method = 'POST';
+            method = "POST";
             break;
-                    case 'restart':
+          case "restart":
             endpoint = `/api/hassio/addons/${params.slug}/restart`;
-                        method = 'POST';
+            method = "POST";
             break;
         }
 
@@ -80,16 +103,18 @@ export const addonTool: Tool = {
           method,
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
           ...(Object.keys(body).length > 0 && { body: JSON.stringify(body) }),
         });
 
         if (!response.ok) {
-                    throw new Error(`Failed to ${params.action} add-on: ${response.statusText}`);
+          throw new Error(
+            `Failed to ${params.action} add-on: ${response.statusText}`,
+          );
         }
 
-                const data = await response.json() as HassAddonInfoResponse;
+        const data = (await response.json()) as HassAddonInfoResponse;
         return {
           success: true,
           message: `Successfully ${params.action}ed add-on ${params.slug}`,
@@ -99,7 +124,8 @@ export const addonTool: Tool = {
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/automation-config.tool.ts

@@ -1,95 +1,136 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, AutomationConfigParams, AutomationConfig, AutomationResponse } from '../types/index.js';
+import {
-import { APP_CONFIG } from '../config/app.config.js';
+  Tool,
+  AutomationConfigParams,
+  AutomationConfig,
+  AutomationResponse,
+} from "../types/index.js";
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const automationConfigTool: Tool = {
-    name: 'automation_config',
+  name: "automation_config",
-    description: 'Advanced automation configuration and management',
+  description: "Advanced automation configuration and management",
   parameters: z.object({
-        action: z.enum(['create', 'update', 'delete', 'duplicate'])
+    action: z
-            .describe('Action to perform with automation config'),
+      .enum(["create", "update", "delete", "duplicate"])
-        automation_id: z.string().optional()
+      .describe("Action to perform with automation config"),
-            .describe('Automation ID (required for update, delete, and duplicate)'),
+    automation_id: z
-        config: z.object({
+      .string()
-            alias: z.string().describe('Friendly name for the automation'),
+      .optional()
-            description: z.string().optional().describe('Description of what the automation does'),
+      .describe("Automation ID (required for update, delete, and duplicate)"),
-            mode: z.enum(['single', 'parallel', 'queued', 'restart']).optional()
+    config: z
-                .describe('How multiple triggerings are handled'),
+      .object({
-            trigger: z.array(z.any()).describe('List of triggers'),
+        alias: z.string().describe("Friendly name for the automation"),
-            condition: z.array(z.any()).optional().describe('List of conditions'),
+        description: z
-            action: z.array(z.any()).describe('List of actions'),
+          .string()
-        }).optional().describe('Automation configuration (required for create and update)'),
+          .optional()
+          .describe("Description of what the automation does"),
+        mode: z
+          .enum(["single", "parallel", "queued", "restart"])
+          .optional()
+          .describe("How multiple triggerings are handled"),
+        trigger: z.array(z.any()).describe("List of triggers"),
+        condition: z.array(z.any()).optional().describe("List of conditions"),
+        action: z.array(z.any()).describe("List of actions"),
+      })
+      .optional()
+      .describe("Automation configuration (required for create and update)"),
   }),
   execute: async (params: AutomationConfigParams) => {
     try {
       switch (params.action) {
-                case 'create': {
+        case "create": {
           if (!params.config) {
-                        throw new Error('Configuration is required for creating automation');
+            throw new Error(
+              "Configuration is required for creating automation",
+            );
           }
 
-                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config`, {
+          const response = await fetch(
-                        method: 'POST',
+            `${APP_CONFIG.HASS_HOST}/api/config/automation/config`,
+            {
+              method: "POST",
               headers: {
                 Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                            'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
               body: JSON.stringify(params.config),
-                    });
+            },
+          );
 
           if (!response.ok) {
-                        throw new Error(`Failed to create automation: ${response.statusText}`);
+            throw new Error(
+              `Failed to create automation: ${response.statusText}`,
+            );
           }
 
-                    const responseData = await response.json() as { automation_id: string };
+          const responseData = (await response.json()) as {
+            automation_id: string;
+          };
           return {
             success: true,
-                        message: 'Successfully created automation',
+            message: "Successfully created automation",
             automation_id: responseData.automation_id,
           };
         }
 
-                case 'update': {
+        case "update": {
           if (!params.automation_id || !params.config) {
-                        throw new Error('Automation ID and configuration are required for updating automation');
+            throw new Error(
+              "Automation ID and configuration are required for updating automation",
+            );
           }
 
-                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+          const response = await fetch(
-                        method: 'PUT',
+            `${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`,
+            {
+              method: "PUT",
               headers: {
                 Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                            'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
               body: JSON.stringify(params.config),
-                    });
+            },
+          );
 
           if (!response.ok) {
-                        throw new Error(`Failed to update automation: ${response.statusText}`);
+            throw new Error(
+              `Failed to update automation: ${response.statusText}`,
+            );
           }
 
-                    const responseData = await response.json() as { automation_id: string };
+          const responseData = (await response.json()) as {
+            automation_id: string;
+          };
           return {
             success: true,
             automation_id: responseData.automation_id,
-                        message: 'Automation updated successfully'
+            message: "Automation updated successfully",
           };
         }
 
-                case 'delete': {
+        case "delete": {
           if (!params.automation_id) {
-                        throw new Error('Automation ID is required for deleting automation');
+            throw new Error(
+              "Automation ID is required for deleting automation",
+            );
           }
 
-                    const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+          const response = await fetch(
-                        method: 'DELETE',
+            `${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`,
+            {
+              method: "DELETE",
               headers: {
                 Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                            'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
-                    });
+            },
+          );
 
           if (!response.ok) {
-                        throw new Error(`Failed to delete automation: ${response.statusText}`);
+            throw new Error(
+              `Failed to delete automation: ${response.statusText}`,
+            );
           }
 
           return {
@@ -98,41 +139,54 @@ export const automationConfigTool: Tool = {
           };
         }
 
-                case 'duplicate': {
+        case "duplicate": {
           if (!params.automation_id) {
-                        throw new Error('Automation ID is required for duplicating automation');
+            throw new Error(
+              "Automation ID is required for duplicating automation",
+            );
           }
 
           // First, get the existing automation config
-                    const getResponse = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`, {
+          const getResponse = await fetch(
+            `${APP_CONFIG.HASS_HOST}/api/config/automation/config/${params.automation_id}`,
+            {
               headers: {
                 Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                            'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
-                    });
+            },
+          );
 
           if (!getResponse.ok) {
-                        throw new Error(`Failed to get automation config: ${getResponse.statusText}`);
+            throw new Error(
+              `Failed to get automation config: ${getResponse.statusText}`,
+            );
           }
 
-                    const config = await getResponse.json() as AutomationConfig;
+          const config = (await getResponse.json()) as AutomationConfig;
           config.alias = `${config.alias} (Copy)`;
 
           // Create new automation with modified config
-                    const createResponse = await fetch(`${APP_CONFIG.HASS_HOST}/api/config/automation/config`, {
+          const createResponse = await fetch(
-                        method: 'POST',
+            `${APP_CONFIG.HASS_HOST}/api/config/automation/config`,
+            {
+              method: "POST",
               headers: {
                 Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                            'Content-Type': 'application/json',
+                "Content-Type": "application/json",
               },
               body: JSON.stringify(config),
-                    });
+            },
+          );
 
           if (!createResponse.ok) {
-                        throw new Error(`Failed to create duplicate automation: ${createResponse.statusText}`);
+            throw new Error(
+              `Failed to create duplicate automation: ${createResponse.statusText}`,
+            );
           }
 
-                    const newAutomation = await createResponse.json() as AutomationResponse;
+          const newAutomation =
+            (await createResponse.json()) as AutomationResponse;
           return {
             success: true,
             message: `Successfully duplicated automation ${params.automation_id}`,
@@ -143,7 +197,8 @@ export const automationConfigTool: Tool = {
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/automation.tool.ts

@@ -1,62 +1,85 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, AutomationParams, HassState, AutomationResponse } from '../types/index.js';
+import {
-import { APP_CONFIG } from '../config/app.config.js';
+  Tool,
+  AutomationParams,
+  HassState,
+  AutomationResponse,
+} from "../types/index.js";
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const automationTool: Tool = {
-    name: 'automation',
+  name: "automation",
-    description: 'Manage Home Assistant automations',
+  description: "Manage Home Assistant automations",
   parameters: z.object({
-        action: z.enum(['list', 'toggle', 'trigger']).describe('Action to perform with automation'),
+    action: z
-        automation_id: z.string().optional().describe('Automation ID (required for toggle and trigger actions)'),
+      .enum(["list", "toggle", "trigger"])
+      .describe("Action to perform with automation"),
+    automation_id: z
+      .string()
+      .optional()
+      .describe("Automation ID (required for toggle and trigger actions)"),
   }),
   execute: async (params: AutomationParams) => {
     try {
-            if (params.action === 'list') {
+      if (params.action === "list") {
         const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/states`, {
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
         });
 
         if (!response.ok) {
-                    throw new Error(`Failed to fetch automations: ${response.statusText}`);
+          throw new Error(
+            `Failed to fetch automations: ${response.statusText}`,
+          );
         }
 
         const states = (await response.json()) as HassState[];
-                const automations = states.filter((state) => state.entity_id.startsWith('automation.'));
+        const automations = states.filter((state) =>
+          state.entity_id.startsWith("automation."),
+        );
 
         return {
           success: true,
           automations: automations.map((automation) => ({
             entity_id: automation.entity_id,
-                        name: automation.attributes.friendly_name || automation.entity_id.split('.')[1],
+            name:
+              automation.attributes.friendly_name ||
+              automation.entity_id.split(".")[1],
             state: automation.state,
             last_triggered: automation.attributes.last_triggered,
           })),
         };
       } else {
         if (!params.automation_id) {
-                    throw new Error('Automation ID is required for toggle and trigger actions');
+          throw new Error(
+            "Automation ID is required for toggle and trigger actions",
+          );
         }
 
-                const service = params.action === 'toggle' ? 'toggle' : 'trigger';
+        const service = params.action === "toggle" ? "toggle" : "trigger";
-                const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/services/automation/${service}`, {
+        const response = await fetch(
-                    method: 'POST',
+          `${APP_CONFIG.HASS_HOST}/api/services/automation/${service}`,
+          {
+            method: "POST",
             headers: {
               Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+              "Content-Type": "application/json",
             },
             body: JSON.stringify({
               entity_id: params.automation_id,
             }),
-                });
+          },
+        );
 
         if (!response.ok) {
-                    throw new Error(`Failed to ${service} automation: ${response.statusText}`);
+          throw new Error(
+            `Failed to ${service} automation: ${response.statusText}`,
+          );
         }
 
-                const responseData = await response.json() as AutomationResponse;
+        const responseData = (await response.json()) as AutomationResponse;
         return {
           success: true,
           message: `Successfully ${service}d automation ${params.automation_id}`,
@@ -66,7 +89,8 @@ export const automationTool: Tool = {
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/control.tool.ts

@@ -1,51 +1,94 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, CommandParams } from '../types/index.js';
+import { Tool, CommandParams } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { DomainSchema } from '../schemas.js';
+import { DomainSchema } from "../schemas.js";
 
 // Define command constants
-const commonCommands = ['turn_on', 'turn_off', 'toggle'] as const;
+const commonCommands = ["turn_on", "turn_off", "toggle"] as const;
-const coverCommands = [...commonCommands, 'open', 'close', 'stop', 'set_position', 'set_tilt_position'] as const;
+const coverCommands = [
-const climateCommands = [...commonCommands, 'set_temperature', 'set_hvac_mode', 'set_fan_mode', 'set_humidity'] as const;
+  ...commonCommands,
+  "open",
+  "close",
+  "stop",
+  "set_position",
+  "set_tilt_position",
+] as const;
+const climateCommands = [
+  ...commonCommands,
+  "set_temperature",
+  "set_hvac_mode",
+  "set_fan_mode",
+  "set_humidity",
+] as const;
 
 export const controlTool: Tool = {
-    name: 'control',
+  name: "control",
-    description: 'Control Home Assistant devices and services',
+  description: "Control Home Assistant devices and services",
   parameters: z.object({
-        command: z.enum([...commonCommands, ...coverCommands, ...climateCommands])
+    command: z
-            .describe('The command to execute'),
+      .enum([...commonCommands, ...coverCommands, ...climateCommands])
-        entity_id: z.string().describe('The entity ID to control'),
+      .describe("The command to execute"),
+    entity_id: z.string().describe("The entity ID to control"),
     // Common parameters
-        state: z.string().optional().describe('The desired state for the entity'),
+    state: z.string().optional().describe("The desired state for the entity"),
     // Light parameters
-        brightness: z.number().min(0).max(255).optional()
+    brightness: z
-            .describe('Brightness level for lights (0-255)'),
+      .number()
-        color_temp: z.number().optional()
+      .min(0)
-            .describe('Color temperature for lights'),
+      .max(255)
-        rgb_color: z.tuple([z.number(), z.number(), z.number()]).optional()
+      .optional()
-            .describe('RGB color values'),
+      .describe("Brightness level for lights (0-255)"),
+    color_temp: z.number().optional().describe("Color temperature for lights"),
+    rgb_color: z
+      .tuple([z.number(), z.number(), z.number()])
+      .optional()
+      .describe("RGB color values"),
     // Cover parameters
-        position: z.number().min(0).max(100).optional()
+    position: z
-            .describe('Position for covers (0-100)'),
+      .number()
-        tilt_position: z.number().min(0).max(100).optional()
+      .min(0)
-            .describe('Tilt position for covers (0-100)'),
+      .max(100)
+      .optional()
+      .describe("Position for covers (0-100)"),
+    tilt_position: z
+      .number()
+      .min(0)
+      .max(100)
+      .optional()
+      .describe("Tilt position for covers (0-100)"),
     // Climate parameters
-        temperature: z.number().optional()
+    temperature: z
-            .describe('Target temperature for climate devices'),
+      .number()
-        target_temp_high: z.number().optional()
+      .optional()
-            .describe('Target high temperature for climate devices'),
+      .describe("Target temperature for climate devices"),
-        target_temp_low: z.number().optional()
+    target_temp_high: z
-            .describe('Target low temperature for climate devices'),
+      .number()
-        hvac_mode: z.enum(['off', 'heat', 'cool', 'heat_cool', 'auto', 'dry', 'fan_only']).optional()
+      .optional()
-            .describe('HVAC mode for climate devices'),
+      .describe("Target high temperature for climate devices"),
-        fan_mode: z.enum(['auto', 'low', 'medium', 'high']).optional()
+    target_temp_low: z
-            .describe('Fan mode for climate devices'),
+      .number()
-        humidity: z.number().min(0).max(100).optional()
+      .optional()
-            .describe('Target humidity for climate devices')
+      .describe("Target low temperature for climate devices"),
+    hvac_mode: z
+      .enum(["off", "heat", "cool", "heat_cool", "auto", "dry", "fan_only"])
+      .optional()
+      .describe("HVAC mode for climate devices"),
+    fan_mode: z
+      .enum(["auto", "low", "medium", "high"])
+      .optional()
+      .describe("Fan mode for climate devices"),
+    humidity: z
+      .number()
+      .min(0)
+      .max(100)
+      .optional()
+      .describe("Target humidity for climate devices"),
   }),
   execute: async (params: CommandParams) => {
     try {
-            const domain = params.entity_id.split('.')[0] as keyof typeof DomainSchema.Values;
+      const domain = params.entity_id.split(
+        ".",
+      )[0] as keyof typeof DomainSchema.Values;
 
       if (!Object.values(DomainSchema.Values).includes(domain)) {
         throw new Error(`Unsupported domain: ${domain}`);
@@ -53,12 +96,12 @@ export const controlTool: Tool = {
 
       const service = params.command;
       const serviceData: Record<string, any> = {
-                entity_id: params.entity_id
+        entity_id: params.entity_id,
       };
 
       // Handle domain-specific parameters
       switch (domain) {
-                case 'light':
+        case "light":
           if (params.brightness !== undefined) {
             serviceData.brightness = params.brightness;
           }
@@ -70,17 +113,20 @@ export const controlTool: Tool = {
           }
           break;
 
-                case 'cover':
+        case "cover":
-                    if (service === 'set_position' && params.position !== undefined) {
+          if (service === "set_position" && params.position !== undefined) {
             serviceData.position = params.position;
           }
-                    if (service === 'set_tilt_position' && params.tilt_position !== undefined) {
+          if (
+            service === "set_tilt_position" &&
+            params.tilt_position !== undefined
+          ) {
             serviceData.tilt_position = params.tilt_position;
           }
           break;
 
-                case 'climate':
+        case "climate":
-                    if (service === 'set_temperature') {
+          if (service === "set_temperature") {
             if (params.temperature !== undefined) {
               serviceData.temperature = params.temperature;
             }
@@ -91,19 +137,19 @@ export const controlTool: Tool = {
               serviceData.target_temp_low = params.target_temp_low;
             }
           }
-                    if (service === 'set_hvac_mode' && params.hvac_mode !== undefined) {
+          if (service === "set_hvac_mode" && params.hvac_mode !== undefined) {
             serviceData.hvac_mode = params.hvac_mode;
           }
-                    if (service === 'set_fan_mode' && params.fan_mode !== undefined) {
+          if (service === "set_fan_mode" && params.fan_mode !== undefined) {
             serviceData.fan_mode = params.fan_mode;
           }
-                    if (service === 'set_humidity' && params.humidity !== undefined) {
+          if (service === "set_humidity" && params.humidity !== undefined) {
             serviceData.humidity = params.humidity;
           }
           break;
 
-                case 'switch':
+        case "switch":
-                case 'contact':
+        case "contact":
           // These domains only support basic operations (turn_on, turn_off, toggle)
           break;
 
@@ -112,28 +158,34 @@ export const controlTool: Tool = {
       }
 
       // Call Home Assistant service
-            const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/services/${domain}/${service}`, {
+      const response = await fetch(
-                method: 'POST',
+        `${APP_CONFIG.HASS_HOST}/api/services/${domain}/${service}`,
+        {
+          method: "POST",
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                    'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
           body: JSON.stringify(serviceData),
-            });
+        },
+      );
 
       if (!response.ok) {
-                throw new Error(`Failed to execute ${service} for ${params.entity_id}: ${response.statusText}`);
+        throw new Error(
+          `Failed to execute ${service} for ${params.entity_id}: ${response.statusText}`,
+        );
       }
 
       return {
         success: true,
-                message: `Successfully executed ${service} for ${params.entity_id}`
+        message: `Successfully executed ${service} for ${params.entity_id}`,
       };
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred'
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
-    }
+  },
 };

src/tools/history.tool.ts

@@ -1,21 +1,35 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, HistoryParams } from '../types/index.js';
+import { Tool, HistoryParams } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const historyTool: Tool = {
-    name: 'get_history',
+  name: "get_history",
-    description: 'Get state history for Home Assistant entities',
+  description: "Get state history for Home Assistant entities",
   parameters: z.object({
-        entity_id: z.string().describe('The entity ID to get history for'),
+    entity_id: z.string().describe("The entity ID to get history for"),
-        start_time: z.string().optional().describe('Start time in ISO format. Defaults to 24 hours ago'),
+    start_time: z
-        end_time: z.string().optional().describe('End time in ISO format. Defaults to now'),
+      .string()
-        minimal_response: z.boolean().optional().describe('Return minimal response to reduce data size'),
+      .optional()
-        significant_changes_only: z.boolean().optional().describe('Only return significant state changes'),
+      .describe("Start time in ISO format. Defaults to 24 hours ago"),
+    end_time: z
+      .string()
+      .optional()
+      .describe("End time in ISO format. Defaults to now"),
+    minimal_response: z
+      .boolean()
+      .optional()
+      .describe("Return minimal response to reduce data size"),
+    significant_changes_only: z
+      .boolean()
+      .optional()
+      .describe("Only return significant state changes"),
   }),
   execute: async (params: HistoryParams) => {
     try {
       const now = new Date();
-            const startTime = params.start_time ? new Date(params.start_time) : new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const startTime = params.start_time
+        ? new Date(params.start_time)
+        : new Date(now.getTime() - 24 * 60 * 60 * 1000);
       const endTime = params.end_time ? new Date(params.end_time) : now;
 
       // Build query parameters
@@ -27,12 +41,15 @@ export const historyTool: Tool = {
         end_time: endTime.toISOString(),
       });
 
-            const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/history/period/${startTime.toISOString()}?${queryParams.toString()}`, {
+      const response = await fetch(
+        `${APP_CONFIG.HASS_HOST}/api/history/period/${startTime.toISOString()}?${queryParams.toString()}`,
+        {
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                    'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
-            });
+        },
+      );
 
       if (!response.ok) {
         throw new Error(`Failed to fetch history: ${response.statusText}`);
@@ -46,7 +63,8 @@ export const historyTool: Tool = {
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/index.ts

@@ -1,28 +1,28 @@
-import { Tool } from '../types/index.js';
+import { Tool } from "../types/index.js";
-import { listDevicesTool } from './list-devices.tool.js';
+import { listDevicesTool } from "./list-devices.tool.js";
-import { controlTool } from './control.tool.js';
+import { controlTool } from "./control.tool.js";
-import { historyTool } from './history.tool.js';
+import { historyTool } from "./history.tool.js";
-import { sceneTool } from './scene.tool.js';
+import { sceneTool } from "./scene.tool.js";
-import { notifyTool } from './notify.tool.js';
+import { notifyTool } from "./notify.tool.js";
-import { automationTool } from './automation.tool.js';
+import { automationTool } from "./automation.tool.js";
-import { addonTool } from './addon.tool.js';
+import { addonTool } from "./addon.tool.js";
-import { packageTool } from './package.tool.js';
+import { packageTool } from "./package.tool.js";
-import { automationConfigTool } from './automation-config.tool.js';
+import { automationConfigTool } from "./automation-config.tool.js";
-import { subscribeEventsTool } from './subscribe-events.tool.js';
+import { subscribeEventsTool } from "./subscribe-events.tool.js";
-import { getSSEStatsTool } from './sse-stats.tool.js';
+import { getSSEStatsTool } from "./sse-stats.tool.js";
 
 // Tool category types
 export enum ToolCategory {
-    DEVICE = 'device',
+  DEVICE = "device",
-    SYSTEM = 'system',
+  SYSTEM = "system",
-    AUTOMATION = 'automation'
+  AUTOMATION = "automation",
 }
 
 // Tool priority levels
 export enum ToolPriority {
-    HIGH = 'high',
+  HIGH = "high",
-    MEDIUM = 'medium',
+  MEDIUM = "medium",
-    LOW = 'low'
+  LOW = "low",
 }
 
 interface ToolMetadata {
@@ -47,12 +47,12 @@ export const tools: Tool[] = [
   packageTool,
   automationConfigTool,
   subscribeEventsTool,
-    getSSEStatsTool
+  getSSEStatsTool,
 ];
 
 // Function to get a tool by name
 export function getToolByName(name: string): Tool | undefined {
-    return tools.find(tool => tool.name === name);
+  return tools.find((tool) => tool.name === name);
 }
 
 // Function to get all tools
@@ -72,5 +72,5 @@ export {
   packageTool,
   automationConfigTool,
   subscribeEventsTool,
-    getSSEStatsTool
+  getSSEStatsTool,
 };

src/tools/list-devices.tool.ts

@@ -1,18 +1,18 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool } from '../types/index.js';
+import { Tool } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { HassState } from '../types/index.js';
+import { HassState } from "../types/index.js";
 
 export const listDevicesTool: Tool = {
-    name: 'list_devices',
+  name: "list_devices",
-    description: 'List all available Home Assistant devices',
+  description: "List all available Home Assistant devices",
-    parameters: z.object({}).describe('No parameters required'),
+  parameters: z.object({}).describe("No parameters required"),
   execute: async () => {
     try {
       const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/states`, {
         headers: {
           Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                    'Content-Type': 'application/json',
+          "Content-Type": "application/json",
         },
       });
 
@@ -20,12 +20,12 @@ export const listDevicesTool: Tool = {
         throw new Error(`Failed to fetch devices: ${response.statusText}`);
       }
 
-            const states = await response.json() as HassState[];
+      const states = (await response.json()) as HassState[];
       const devices: Record<string, HassState[]> = {};
 
       // Group devices by domain
-            states.forEach(state => {
+      states.forEach((state) => {
-                const [domain] = state.entity_id.split('.');
+        const [domain] = state.entity_id.split(".");
         if (!devices[domain]) {
           devices[domain] = [];
         }
@@ -34,13 +34,14 @@ export const listDevicesTool: Tool = {
 
       return {
         success: true,
-                devices
+        devices,
       };
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred'
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
-    }
+  },
 };

src/tools/notify.tool.ts

@@ -1,33 +1,41 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, NotifyParams } from '../types/index.js';
+import { Tool, NotifyParams } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const notifyTool: Tool = {
-    name: 'notify',
+  name: "notify",
-    description: 'Send notifications through Home Assistant',
+  description: "Send notifications through Home Assistant",
   parameters: z.object({
-        message: z.string().describe('The notification message'),
+    message: z.string().describe("The notification message"),
-        title: z.string().optional().describe('The notification title'),
+    title: z.string().optional().describe("The notification title"),
-        target: z.string().optional().describe('Specific notification target (e.g., mobile_app_phone)'),
+    target: z
-        data: z.record(z.any()).optional().describe('Additional notification data'),
+      .string()
+      .optional()
+      .describe("Specific notification target (e.g., mobile_app_phone)"),
+    data: z.record(z.any()).optional().describe("Additional notification data"),
   }),
   execute: async (params: NotifyParams) => {
     try {
-            const service = params.target ? `notify.${params.target}` : 'notify.notify';
+      const service = params.target
-            const [domain, service_name] = service.split('.');
+        ? `notify.${params.target}`
+        : "notify.notify";
+      const [domain, service_name] = service.split(".");
 
-            const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/services/${domain}/${service_name}`, {
+      const response = await fetch(
-                method: 'POST',
+        `${APP_CONFIG.HASS_HOST}/api/services/${domain}/${service_name}`,
+        {
+          method: "POST",
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                    'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
           body: JSON.stringify({
             message: params.message,
             title: params.title,
             data: params.data,
           }),
-            });
+        },
+      );
 
       if (!response.ok) {
         throw new Error(`Failed to send notification: ${response.statusText}`);
@@ -35,12 +43,13 @@ export const notifyTool: Tool = {
 
       return {
         success: true,
-                message: 'Notification sent successfully',
+        message: "Notification sent successfully",
       };
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/package.tool.ts

@@ -1,76 +1,93 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, PackageParams, HacsResponse } from '../types/index.js';
+import { Tool, PackageParams, HacsResponse } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const packageTool: Tool = {
-    name: 'package',
+  name: "package",
-    description: 'Manage HACS packages and custom components',
+  description: "Manage HACS packages and custom components",
   parameters: z.object({
-        action: z.enum(['list', 'install', 'uninstall', 'update'])
+    action: z
-            .describe('Action to perform with package'),
+      .enum(["list", "install", "uninstall", "update"])
-        category: z.enum(['integration', 'plugin', 'theme', 'python_script', 'appdaemon', 'netdaemon'])
+      .describe("Action to perform with package"),
-            .describe('Package category'),
+    category: z
-        repository: z.string().optional().describe('Repository URL or name (required for install)'),
+      .enum([
-        version: z.string().optional().describe('Version to install'),
+        "integration",
+        "plugin",
+        "theme",
+        "python_script",
+        "appdaemon",
+        "netdaemon",
+      ])
+      .describe("Package category"),
+    repository: z
+      .string()
+      .optional()
+      .describe("Repository URL or name (required for install)"),
+    version: z.string().optional().describe("Version to install"),
   }),
   execute: async (params: PackageParams) => {
     try {
       const hacsBase = `${APP_CONFIG.HASS_HOST}/api/hacs`;
 
-            if (params.action === 'list') {
+      if (params.action === "list") {
-                const response = await fetch(`${hacsBase}/repositories?category=${params.category}`, {
+        const response = await fetch(
+          `${hacsBase}/repositories?category=${params.category}`,
+          {
             headers: {
               Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+              "Content-Type": "application/json",
             },
-                });
+          },
+        );
 
         if (!response.ok) {
           throw new Error(`Failed to fetch packages: ${response.statusText}`);
         }
 
-                const data = await response.json() as HacsResponse;
+        const data = (await response.json()) as HacsResponse;
         return {
           success: true,
           packages: data.repositories,
         };
       } else {
         if (!params.repository) {
-                    throw new Error('Repository is required for this action');
+          throw new Error("Repository is required for this action");
         }
 
-                let endpoint = '';
+        let endpoint = "";
         const body: Record<string, any> = {
           category: params.category,
           repository: params.repository,
         };
 
         switch (params.action) {
-                    case 'install':
+          case "install":
-                        endpoint = '/repository/install';
+            endpoint = "/repository/install";
             if (params.version) {
               body.version = params.version;
             }
             break;
-                    case 'uninstall':
+          case "uninstall":
-                        endpoint = '/repository/uninstall';
+            endpoint = "/repository/uninstall";
             break;
-                    case 'update':
+          case "update":
-                        endpoint = '/repository/update';
+            endpoint = "/repository/update";
             break;
         }
 
         const response = await fetch(`${hacsBase}${endpoint}`, {
-                    method: 'POST',
+          method: "POST",
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
           body: JSON.stringify(body),
         });
 
         if (!response.ok) {
-                    throw new Error(`Failed to ${params.action} package: ${response.statusText}`);
+          throw new Error(
+            `Failed to ${params.action} package: ${response.statusText}`,
+          );
         }
 
         return {
@@ -81,7 +98,8 @@ export const packageTool: Tool = {
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/scene.tool.ts

@@ -1,21 +1,26 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool, SceneParams, HassState } from '../types/index.js';
+import { Tool, SceneParams, HassState } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 export const sceneTool: Tool = {
-    name: 'scene',
+  name: "scene",
-    description: 'Manage and activate Home Assistant scenes',
+  description: "Manage and activate Home Assistant scenes",
   parameters: z.object({
-        action: z.enum(['list', 'activate']).describe('Action to perform with scenes'),
+    action: z
-        scene_id: z.string().optional().describe('Scene ID to activate (required for activate action)'),
+      .enum(["list", "activate"])
+      .describe("Action to perform with scenes"),
+    scene_id: z
+      .string()
+      .optional()
+      .describe("Scene ID to activate (required for activate action)"),
   }),
   execute: async (params: SceneParams) => {
     try {
-            if (params.action === 'list') {
+      if (params.action === "list") {
         const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/states`, {
           headers: {
             Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
         });
 
@@ -24,31 +29,37 @@ export const sceneTool: Tool = {
         }
 
         const states = (await response.json()) as HassState[];
-                const scenes = states.filter((state) => state.entity_id.startsWith('scene.'));
+        const scenes = states.filter((state) =>
+          state.entity_id.startsWith("scene."),
+        );
 
         return {
           success: true,
           scenes: scenes.map((scene) => ({
             entity_id: scene.entity_id,
-                        name: scene.attributes.friendly_name || scene.entity_id.split('.')[1],
+            name:
+              scene.attributes.friendly_name || scene.entity_id.split(".")[1],
             description: scene.attributes.description,
           })),
         };
-            } else if (params.action === 'activate') {
+      } else if (params.action === "activate") {
         if (!params.scene_id) {
-                    throw new Error('Scene ID is required for activate action');
+          throw new Error("Scene ID is required for activate action");
         }
 
-                const response = await fetch(`${APP_CONFIG.HASS_HOST}/api/services/scene/turn_on`, {
+        const response = await fetch(
-                    method: 'POST',
+          `${APP_CONFIG.HASS_HOST}/api/services/scene/turn_on`,
+          {
+            method: "POST",
             headers: {
               Authorization: `Bearer ${APP_CONFIG.HASS_TOKEN}`,
-                        'Content-Type': 'application/json',
+              "Content-Type": "application/json",
             },
             body: JSON.stringify({
               entity_id: params.scene_id,
             }),
-                });
+          },
+        );
 
         if (!response.ok) {
           throw new Error(`Failed to activate scene: ${response.statusText}`);
@@ -60,11 +71,12 @@ export const sceneTool: Tool = {
         };
       }
 
-            throw new Error('Invalid action specified');
+      throw new Error("Invalid action specified");
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred',
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   },

src/tools/sse-stats.tool.ts

@@ -1,33 +1,34 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { Tool } from '../types/index.js';
+import { Tool } from "../types/index.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { sseManager } from '../sse/index.js';
+import { sseManager } from "../sse/index.js";
 
 export const getSSEStatsTool: Tool = {
-    name: 'get_sse_stats',
+  name: "get_sse_stats",
-    description: 'Get SSE connection statistics',
+  description: "Get SSE connection statistics",
   parameters: z.object({
-        token: z.string().describe('Authentication token (required)')
+    token: z.string().describe("Authentication token (required)"),
   }),
   execute: async (params: { token: string }) => {
     try {
       if (params.token !== APP_CONFIG.HASS_TOKEN) {
         return {
           success: false,
-                    message: 'Authentication failed'
+          message: "Authentication failed",
         };
       }
 
       const stats = await sseManager.getStatistics();
       return {
         success: true,
-                statistics: stats
+        statistics: stats,
       };
     } catch (error) {
       return {
         success: false,
-                message: error instanceof Error ? error.message : 'Unknown error occurred'
+        message:
+          error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
-    }
+  },
 };

src/tools/subscribe-events.tool.ts

@@ -1,25 +1,35 @@
-import { z } from 'zod';
+import { z } from "zod";
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
-import { Tool, SSEParams } from '../types/index.js';
+import { Tool, SSEParams } from "../types/index.js";
-import { sseManager } from '../sse/index.js';
+import { sseManager } from "../sse/index.js";
 
 export const subscribeEventsTool: Tool = {
-    name: 'subscribe_events',
+  name: "subscribe_events",
-    description: 'Subscribe to Home Assistant events via Server-Sent Events (SSE)',
+  description:
+    "Subscribe to Home Assistant events via Server-Sent Events (SSE)",
   parameters: z.object({
-        token: z.string().describe('Authentication token (required)'),
+    token: z.string().describe("Authentication token (required)"),
-        events: z.array(z.string()).optional().describe('List of event types to subscribe to'),
+    events: z
-        entity_id: z.string().optional().describe('Specific entity ID to monitor for state changes'),
+      .array(z.string())
-        domain: z.string().optional().describe('Domain to monitor (e.g., "light", "switch", etc.)'),
+      .optional()
+      .describe("List of event types to subscribe to"),
+    entity_id: z
+      .string()
+      .optional()
+      .describe("Specific entity ID to monitor for state changes"),
+    domain: z
+      .string()
+      .optional()
+      .describe('Domain to monitor (e.g., "light", "switch", etc.)'),
   }),
   execute: async (params: SSEParams) => {
     const clientId = uuidv4();
 
     // Set up SSE headers
     const responseHeaders = {
-            'Content-Type': 'text/event-stream',
+      "Content-Type": "text/event-stream",
-            'Cache-Control': 'no-cache',
+      "Cache-Control": "no-cache",
-            'Connection': 'keep-alive',
+      Connection: "keep-alive",
     };
 
     // Create SSE client
@@ -29,9 +39,9 @@ export const subscribeEventsTool: Tool = {
         return {
           headers: responseHeaders,
           body: `data: ${data}\n\n`,
-                    keepAlive: true
+          keepAlive: true,
         };
-            }
+      },
     };
 
     // Add client to SSE manager with authentication
@@ -40,7 +50,9 @@ export const subscribeEventsTool: Tool = {
     if (!sseClient || !sseClient.authenticated) {
       return {
         success: false,
-                message: sseClient ? 'Authentication failed' : 'Maximum client limit reached'
+        message: sseClient
+          ? "Authentication failed"
+          : "Maximum client limit reached",
       };
     }
 
@@ -54,7 +66,10 @@ export const subscribeEventsTool: Tool = {
 
     // Subscribe to specific entity if provided
     if (params.entity_id) {
-            console.log(`Client ${clientId} subscribing to entity:`, params.entity_id);
+      console.log(
+        `Client ${clientId} subscribing to entity:`,
+        params.entity_id,
+      );
       sseManager.subscribeToEntity(clientId, params.entity_id);
     }
 
@@ -67,18 +82,18 @@ export const subscribeEventsTool: Tool = {
     return {
       headers: responseHeaders,
       body: `data: ${JSON.stringify({
-                type: 'connection',
+        type: "connection",
-                status: 'connected',
+        status: "connected",
         id: clientId,
         authenticated: true,
         subscriptions: {
           events: params.events || [],
           entities: params.entity_id ? [params.entity_id] : [],
-                    domains: params.domain ? [params.domain] : []
+          domains: params.domain ? [params.domain] : [],
         },
-                timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       })}\n\n`,
-            keepAlive: true
+      keepAlive: true,
     };
-    }
+  },
 };

src/types/bun.d.ts

@@ -1,9 +1,9 @@
-declare module 'bun:test' {
+declare module "bun:test" {
   export interface Mock<T extends (...args: any[]) => any> {
     (...args: Parameters<T>): ReturnType<T>;
     mock: {
       calls: Array<{ args: Parameters<T>; returned: ReturnType<T> }>;
-            results: Array<{ type: 'return' | 'throw'; value: any }>;
+      results: Array<{ type: "return" | "throw"; value: any }>;
       instances: any[];
       lastCall: { args: Parameters<T>; returned: ReturnType<T> } | undefined;
     };
@@ -15,7 +15,7 @@ declare module 'bun:test' {
   }
 
   export function mock<T extends (...args: any[]) => any>(
-        implementation?: T
+    implementation?: T,
   ): Mock<T>;
 
   export function describe(name: string, fn: () => void): void;

src/types/hass.d.ts

@@ -30,17 +30,17 @@ declare namespace HomeAssistant {
   }
 
   interface AuthMessage extends WebsocketMessage {
-        type: 'auth';
+    type: "auth";
     access_token: string;
   }
 
   interface SubscribeEventsMessage extends WebsocketMessage {
-        type: 'subscribe_events';
+    type: "subscribe_events";
     event_type?: string;
   }
 
   interface StateChangedEvent {
-        event_type: 'state_changed';
+    event_type: "state_changed";
     data: {
       entity_id: string;
       new_state: Entity | null;

src/types/hass.ts

@@ -1,11 +1,11 @@
 export interface AuthMessage {
-    type: 'auth';
+  type: "auth";
   access_token: string;
 }
 
 export interface ResultMessage {
   id: number;
-    type: 'result';
+  type: "result";
   success: boolean;
   result?: any;
 }
@@ -41,7 +41,7 @@ export interface Entity {
 }
 
 export interface StateChangedEvent extends Event {
-    event_type: 'state_changed';
+  event_type: "state_changed";
   data: {
     entity_id: string;
     new_state: Entity | null;
@@ -83,4 +83,3 @@ export interface HassEvent {
     user_id?: string;
   };
 }
-

src/types/index.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 /**
  * Interface for a tool that can be executed by the MCP
@@ -186,7 +186,7 @@ export interface AutomationConfig {
   /** Automation description */
   description?: string;
   /** How multiple triggers are handled */
-    mode?: 'single' | 'parallel' | 'queued' | 'restart';
+  mode?: "single" | "parallel" | "queued" | "restart";
   /** List of triggers */
   trigger: any[];
   /** List of conditions */
@@ -251,7 +251,7 @@ export interface HistoryParams {
  */
 export interface SceneParams {
   /** Action to perform */
-    action: 'list' | 'activate';
+  action: "list" | "activate";
   /** Scene ID for activation */
   scene_id?: string;
 }
@@ -277,7 +277,7 @@ export interface NotifyParams {
  */
 export interface AutomationParams {
   /** Action to perform */
-    action: 'list' | 'toggle' | 'trigger';
+  action: "list" | "toggle" | "trigger";
   /** Automation ID */
   automation_id?: string;
 }
@@ -288,7 +288,14 @@ export interface AutomationParams {
  */
 export interface AddonParams {
   /** Action to perform */
-    action: 'list' | 'info' | 'install' | 'uninstall' | 'start' | 'stop' | 'restart';
+  action:
+    | "list"
+    | "info"
+    | "install"
+    | "uninstall"
+    | "start"
+    | "stop"
+    | "restart";
   /** Add-on slug */
   slug?: string;
   /** Version to install */
@@ -301,9 +308,15 @@ export interface AddonParams {
  */
 export interface PackageParams {
   /** Action to perform */
-    action: 'list' | 'install' | 'uninstall' | 'update';
+  action: "list" | "install" | "uninstall" | "update";
   /** Package category */
-    category: 'integration' | 'plugin' | 'theme' | 'python_script' | 'appdaemon' | 'netdaemon';
+  category:
+    | "integration"
+    | "plugin"
+    | "theme"
+    | "python_script"
+    | "appdaemon"
+    | "netdaemon";
   /** Repository URL or name */
   repository?: string;
   /** Version to install */
@@ -316,7 +329,7 @@ export interface PackageParams {
  */
 export interface AutomationConfigParams {
   /** Action to perform */
-    action: 'create' | 'update' | 'delete' | 'duplicate';
+  action: "create" | "update" | "delete" | "duplicate";
   /** Automation ID */
   automation_id?: string;
   /** Automation configuration */
@@ -326,7 +339,7 @@ export interface AutomationConfigParams {
     /** Automation description */
     description?: string;
     /** How multiple triggers are handled */
-        mode?: 'single' | 'parallel' | 'queued' | 'restart';
+    mode?: "single" | "parallel" | "queued" | "restart";
     /** List of triggers */
     trigger: any[];
     /** List of conditions */

src/utils/log-rotation.ts

@@ -7,14 +7,14 @@
  * @module log-rotation
  */
 
-import fs from 'fs/promises';
+import fs from "fs/promises";
-import path from 'path';
+import path from "path";
-import { glob } from 'glob';
+import { glob } from "glob";
-import { logger } from './logger.js';
+import { logger } from "./logger.js";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
-import { unlink } from 'fs/promises';
+import { unlink } from "fs/promises";
-import { join } from 'path';
+import { join } from "path";
-import { promisify } from 'util';
+import { promisify } from "util";
 
 const globPromise = promisify(glob);
 
@@ -73,7 +73,7 @@ const parseDuration = (duration: string): number => {
  */
 const getLogFiles = async (): Promise<LogFileInfo[]> => {
   const logDir = APP_CONFIG.LOGGING.DIR;
-    const files: string[] = await glob('*.log*', { cwd: logDir });
+  const files: string[] = await glob("*.log*", { cwd: logDir });
 
   const fileInfos: LogFileInfo[] = [];
   for (const file of files) {
@@ -97,9 +97,12 @@ const getLogFiles = async (): Promise<LogFileInfo[]> => {
 /**
  * Clean up old log files
  */
-export async function cleanupOldLogs(logDir: string, maxDays: number): Promise<void> {
+export async function cleanupOldLogs(
+  logDir: string,
+  maxDays: number,
+): Promise<void> {
   try {
-        const files: string[] = await glob('*.log*', { cwd: logDir });
+    const files: string[] = await glob("*.log*", { cwd: logDir });
 
     const now = Date.now();
     const maxAge = maxDays * 24 * 60 * 60 * 1000;
@@ -115,7 +118,7 @@ export async function cleanupOldLogs(logDir: string, maxDays: number): Promise<v
       }
     }
   } catch (error) {
-        logger.error('Error cleaning up old logs:', error);
+    logger.error("Error cleaning up old logs:", error);
   }
 }
 
@@ -128,15 +131,15 @@ const checkLogSize = async (): Promise<void> => {
     const files = await getLogFiles();
 
     for (const file of files) {
-            if (file.size > maxSize && !file.filename.endsWith('.gz')) {
+      if (file.size > maxSize && !file.filename.endsWith(".gz")) {
         // Current log file is handled by winston-daily-rotate-file
-                if (!file.filename.includes(new Date().toISOString().split('T')[0])) {
+        if (!file.filename.includes(new Date().toISOString().split("T")[0])) {
           logger.debug(`Log file exceeds max size: ${file.filename}`);
         }
       }
     }
   } catch (error) {
-        logger.error('Error checking log sizes:', error);
+    logger.error("Error checking log sizes:", error);
   }
 };
 
@@ -146,30 +149,40 @@ const checkLogSize = async (): Promise<void> => {
  */
 export const initLogRotation = (): void => {
   // Check log sizes every hour
-    setInterval(() => {
+  setInterval(
-        checkLogSize().catch(error => {
+    () => {
-            logger.error('Error checking log sizes:', error);
+      checkLogSize().catch((error) => {
+        logger.error("Error checking log sizes:", error);
       });
-    }, 60 * 60 * 1000);
+    },
+    60 * 60 * 1000,
+  );
 
   // Clean up old logs daily
-    setInterval(() => {
+  setInterval(
-        cleanupOldLogs(APP_CONFIG.LOGGING.DIR, parseDuration(APP_CONFIG.LOGGING.MAX_DAYS))
+    () => {
-            .catch(error => {
+      cleanupOldLogs(
-                logger.error('Error cleaning up old logs:', error);
+        APP_CONFIG.LOGGING.DIR,
+        parseDuration(APP_CONFIG.LOGGING.MAX_DAYS),
+      ).catch((error) => {
+        logger.error("Error cleaning up old logs:", error);
       });
-    }, 24 * 60 * 60 * 1000);
+    },
+    24 * 60 * 60 * 1000,
+  );
 
   // Initial check
-    checkLogSize().catch(error => {
+  checkLogSize().catch((error) => {
-        logger.error('Error in initial log size check:', error);
+    logger.error("Error in initial log size check:", error);
   });
 
   // Initial cleanup
-    cleanupOldLogs(APP_CONFIG.LOGGING.DIR, parseDuration(APP_CONFIG.LOGGING.MAX_DAYS))
+  cleanupOldLogs(
-        .catch(error => {
+    APP_CONFIG.LOGGING.DIR,
-            logger.error('Error in initial log cleanup:', error);
+    parseDuration(APP_CONFIG.LOGGING.MAX_DAYS),
+  ).catch((error) => {
+    logger.error("Error in initial log cleanup:", error);
   });
 
-    logger.info('Log rotation initialized');
+  logger.info("Log rotation initialized");
 };

src/utils/logger.ts

@@ -7,9 +7,9 @@
  * @module logger
  */
 
-import winston from 'winston';
+import winston from "winston";
-import DailyRotateFile from 'winston-daily-rotate-file';
+import DailyRotateFile from "winston-daily-rotate-file";
-import { APP_CONFIG } from '../config/app.config.js';
+import { APP_CONFIG } from "../config/app.config.js";
 
 /**
  * Log levels configuration
@@ -28,11 +28,11 @@ const levels = {
  * Defines colors for different log levels
  */
 const colors = {
-    error: 'red',
+  error: "red",
-    warn: 'yellow',
+  warn: "yellow",
-    info: 'green',
+  info: "green",
-    http: 'magenta',
+  http: "magenta",
-    debug: 'white',
+  debug: "white",
 };
 
 /**
@@ -45,7 +45,7 @@ winston.addColors(colors);
  * Defines how log messages are formatted
  */
 const format = winston.format.combine(
-    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" }),
   winston.format.colorize({ all: true }),
   winston.format.printf(
     (info) => `${info.timestamp} ${info.level}: ${info.message}`,
@@ -57,16 +57,16 @@ const format = winston.format.combine(
  * Configures how logs are rotated and stored
  */
 const dailyRotateFileTransport = new DailyRotateFile({
-    filename: 'logs/%DATE%.log',
+  filename: "logs/%DATE%.log",
-    datePattern: 'YYYY-MM-DD',
+  datePattern: "YYYY-MM-DD",
   zippedArchive: true,
-    maxSize: '20m',
+  maxSize: "20m",
-    maxFiles: '14d',
+  maxFiles: "14d",
   format: winston.format.combine(
     winston.format.uncolorize(),
     winston.format.timestamp(),
-        winston.format.json()
+    winston.format.json(),
-    )
+  ),
 });
 
 /**
@@ -74,35 +74,35 @@ const dailyRotateFileTransport = new DailyRotateFile({
  * Stores error logs in a separate file
  */
 const errorFileTransport = new DailyRotateFile({
-    filename: 'logs/error-%DATE%.log',
+  filename: "logs/error-%DATE%.log",
-    datePattern: 'YYYY-MM-DD',
+  datePattern: "YYYY-MM-DD",
-    level: 'error',
+  level: "error",
   zippedArchive: true,
-    maxSize: '20m',
+  maxSize: "20m",
-    maxFiles: '14d',
+  maxFiles: "14d",
   format: winston.format.combine(
     winston.format.uncolorize(),
     winston.format.timestamp(),
-        winston.format.json()
+    winston.format.json(),
-    )
+  ),
 });
 
 /**
  * Create the logger instance
  */
 const logger = winston.createLogger({
-    level: APP_CONFIG.NODE_ENV === 'development' ? 'debug' : 'info',
+  level: APP_CONFIG.NODE_ENV === "development" ? "debug" : "info",
   levels,
   format,
   transports: [
     new winston.transports.Console({
       format: winston.format.combine(
         winston.format.colorize(),
-                winston.format.simple()
+        winston.format.simple(),
-            )
+      ),
     }),
     dailyRotateFileTransport,
-        errorFileTransport
+    errorFileTransport,
   ],
 });
 

src/websocket/client.ts

@@ -1,5 +1,5 @@
-import WebSocket from 'ws';
+import WebSocket from "ws";
-import { EventEmitter } from 'events';
+import { EventEmitter } from "events";
 
 export class HassWebSocketClient extends EventEmitter {
   private ws: WebSocket | null = null;
@@ -17,7 +17,7 @@ export class HassWebSocketClient extends EventEmitter {
       autoReconnect?: boolean;
       maxReconnectAttempts?: number;
       reconnectDelay?: number;
-        } = {}
+    } = {},
   ) {
     super();
     this.maxReconnectAttempts = options.maxReconnectAttempts || 5;
@@ -29,32 +29,32 @@ export class HassWebSocketClient extends EventEmitter {
       try {
         this.ws = new WebSocket(this.url);
 
-                this.ws.on('open', () => {
+        this.ws.on("open", () => {
           this.authenticate();
         });
 
-                this.ws.on('message', (data: string) => {
+        this.ws.on("message", (data: string) => {
           const message = JSON.parse(data);
           this.handleMessage(message);
         });
 
-                this.ws.on('close', () => {
+        this.ws.on("close", () => {
           this.handleDisconnect();
         });
 
-                this.ws.on('error', (error) => {
+        this.ws.on("error", (error) => {
-                    this.emit('error', error);
+          this.emit("error", error);
           reject(error);
         });
 
-                this.once('auth_ok', () => {
+        this.once("auth_ok", () => {
           this.authenticated = true;
           this.reconnectAttempts = 0;
           resolve();
         });
 
-                this.once('auth_invalid', () => {
+        this.once("auth_invalid", () => {
-                    reject(new Error('Authentication failed'));
+          reject(new Error("Authentication failed"));
         });
       } catch (error) {
         reject(error);
@@ -64,26 +64,26 @@ export class HassWebSocketClient extends EventEmitter {
 
   private authenticate(): void {
     this.send({
-            type: 'auth',
+      type: "auth",
-            access_token: this.token
+      access_token: this.token,
     });
   }
 
   private handleMessage(message: any): void {
     switch (message.type) {
-            case 'auth_required':
+      case "auth_required":
         this.authenticate();
         break;
-            case 'auth_ok':
+      case "auth_ok":
-                this.emit('auth_ok');
+        this.emit("auth_ok");
         break;
-            case 'auth_invalid':
+      case "auth_invalid":
-                this.emit('auth_invalid');
+        this.emit("auth_invalid");
         break;
-            case 'event':
+      case "event":
         this.handleEvent(message);
         break;
-            case 'result':
+      case "result":
         this.emit(`result_${message.id}`, message);
         break;
     }
@@ -94,26 +94,35 @@ export class HassWebSocketClient extends EventEmitter {
     if (subscription) {
       subscription(message.event.data);
     }
-        this.emit('event', message.event);
+    this.emit("event", message.event);
   }
 
   private handleDisconnect(): void {
     this.authenticated = false;
-        this.emit('disconnected');
+    this.emit("disconnected");
 
-        if (this.options.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+    if (
-            setTimeout(() => {
+      this.options.autoReconnect &&
+      this.reconnectAttempts < this.maxReconnectAttempts
+    ) {
+      setTimeout(
+        () => {
           this.reconnectAttempts++;
           this.connect().catch((error) => {
-                    this.emit('error', error);
+            this.emit("error", error);
           });
-            }, this.reconnectDelay * Math.pow(2, this.reconnectAttempts));
+        },
+        this.reconnectDelay * Math.pow(2, this.reconnectAttempts),
+      );
     }
   }
 
-    public async subscribeEvents(eventType: string, callback: (data: any) => void): Promise<number> {
+  public async subscribeEvents(
+    eventType: string,
+    callback: (data: any) => void,
+  ): Promise<number> {
     if (!this.authenticated) {
-            throw new Error('Not authenticated');
+      throw new Error("Not authenticated");
     }
 
     const id = this.messageId++;
@@ -122,15 +131,15 @@ export class HassWebSocketClient extends EventEmitter {
     return new Promise((resolve, reject) => {
       this.send({
         id,
-                type: 'subscribe_events',
+        type: "subscribe_events",
-                event_type: eventType
+        event_type: eventType,
       });
 
       this.once(`result_${id}`, (message) => {
         if (message.success) {
           resolve(id);
         } else {
-                    reject(new Error(message.error?.message || 'Subscription failed'));
+          reject(new Error(message.error?.message || "Subscription failed"));
         }
       });
     });
@@ -138,22 +147,22 @@ export class HassWebSocketClient extends EventEmitter {
 
   public async unsubscribeEvents(subscription: number): Promise<void> {
     if (!this.authenticated) {
-            throw new Error('Not authenticated');
+      throw new Error("Not authenticated");
     }
 
     const id = this.messageId++;
     return new Promise((resolve, reject) => {
       this.send({
         id,
-                type: 'unsubscribe_events',
+        type: "unsubscribe_events",
-                subscription
+        subscription,
       });
 
       this.once(`result_${id}`, (message) => {
         if (message.success) {
           resolve();
         } else {
-                    reject(new Error(message.error?.message || 'Unsubscribe failed'));
+          reject(new Error(message.error?.message || "Unsubscribe failed"));
         }
       });
     });

tsconfig.json

@@ -1,9 +1,9 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "ESNext",
+    "module": "NodeNext",
-    "moduleResolution": "node",
+    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
+    "outDir": "dist",
     "rootDir": ".",
     "strict": true,
     "esModuleInterop": true,
@@ -16,8 +16,6 @@
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "types": [
-      "node",
-      "jest",
       "bun-types"
     ],
     "typeRoots": [
@@ -28,11 +26,8 @@
     ],
     "baseUrl": ".",
     "paths": {
-      "@src/*": [
+      "*": [
-        "src/*"
+        "node_modules/*"
-      ],
-      "@tests/*": [
-        "__tests__/*"
       ]
     }
   },