@coffeerunhobby/mcp-ha-connect 0.5.0

package/tests/haClient/updates.test.ts

@@ -0,0 +1,193 @@
+/**
+ * UpdateOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UpdateOperations } from '../../src/haClient/updates.js';
+import type { EntityOperations } from '../../src/haClient/entities.js';
+import type { Entity } from '../../src/types/index.js';
+
+describe('UpdateOperations', () => {
+  let mockEntityOps: EntityOperations;
+  let updateOps: UpdateOperations;
+
+  const mockUpdateEntities: Entity[] = [
+    {
+      entity_id: 'update.home_assistant_core_update',
+      state: 'on', // Update available
+      attributes: {
+        friendly_name: 'Home Assistant Core Update',
+        title: 'Home Assistant Core',
+        installed_version: '2026.1.0',
+        latest_version: '2026.1.1',
+      },
+      last_changed: '2026-01-08T10:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-1', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'update.home_assistant_supervisor_update',
+      state: 'off', // No update
+      attributes: {
+        friendly_name: 'Home Assistant Supervisor Update',
+        title: 'Home Assistant Supervisor',
+        installed_version: '2026.01.1',
+        latest_version: '2026.01.1',
+      },
+      last_changed: '2026-01-08T09:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-2', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'update.home_assistant_operating_system_update',
+      state: 'on', // Update available
+      attributes: {
+        friendly_name: 'Home Assistant Operating System Update',
+        title: 'Home Assistant OS',
+        installed_version: '11.2',
+        latest_version: '11.3',
+      },
+      last_changed: '2026-01-08T08:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-3', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'update.esphome_update',
+      state: 'on', // Update available
+      attributes: {
+        friendly_name: 'ESPHome Update',
+        title: 'ESPHome',
+        installed_version: '2025.12.1',
+        latest_version: '2026.1.0',
+      },
+      last_changed: '2026-01-08T07:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-4', parent_id: null, user_id: null },
+    },
+  ];
+
+  beforeEach(() => {
+    mockEntityOps = {
+      getEntitiesByDomain: vi.fn().mockResolvedValue(mockUpdateEntities),
+    } as unknown as EntityOperations;
+
+    updateOps = new UpdateOperations(mockEntityOps);
+  });
+
+  describe('getAvailableUpdates', () => {
+    it('should fetch update entities', async () => {
+      const result = await updateOps.getAvailableUpdates();
+
+      expect(mockEntityOps.getEntitiesByDomain).toHaveBeenCalledWith('update');
+      expect(result.entities).toEqual(mockUpdateEntities);
+    });
+
+    it('should filter to only available updates (state = on)', async () => {
+      const result = await updateOps.getAvailableUpdates();
+
+      expect(result.updates).toHaveLength(3);
+      expect(result.updates.every(u => u.version_current !== u.version_latest)).toBe(true);
+    });
+
+    it('should categorize core updates', async () => {
+      const result = await updateOps.getAvailableUpdates();
+
+      const coreUpdate = result.updates.find(u => u.update_type === 'core');
+      expect(coreUpdate).toEqual({
+        update_type: 'core',
+        name: 'Home Assistant Core',
+        version_current: '2026.1.0',
+        version_latest: '2026.1.1',
+      });
+    });
+
+    it('should categorize OS updates', async () => {
+      const result = await updateOps.getAvailableUpdates();
+
+      const osUpdate = result.updates.find(u => u.update_type === 'os');
+      expect(osUpdate).toEqual({
+        update_type: 'os',
+        name: 'Home Assistant OS',
+        version_current: '11.2',
+        version_latest: '11.3',
+      });
+    });
+
+    it('should categorize addon updates', async () => {
+      const result = await updateOps.getAvailableUpdates();
+
+      const addonUpdate = result.updates.find(u => u.update_type === 'addon');
+      expect(addonUpdate).toEqual({
+        update_type: 'addon',
+        name: 'ESPHome',
+        version_current: '2025.12.1',
+        version_latest: '2026.1.0',
+      });
+    });
+
+    it('should return empty updates when all entities are up to date', async () => {
+      (mockEntityOps.getEntitiesByDomain as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          entity_id: 'update.test',
+          state: 'off', // No update
+          attributes: {
+            title: 'Test',
+            installed_version: '1.0.0',
+            latest_version: '1.0.0',
+          },
+          last_changed: '2026-01-08T10:00:00.000Z',
+          last_updated: '2026-01-08T10:00:00.000Z',
+          context: { id: 'ctx-1', parent_id: null, user_id: null },
+        },
+      ]);
+
+      const result = await updateOps.getAvailableUpdates();
+
+      expect(result.updates).toEqual([]);
+      expect(result.entities).toHaveLength(1);
+    });
+
+    it('should handle entities without version info', async () => {
+      (mockEntityOps.getEntitiesByDomain as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          entity_id: 'update.incomplete',
+          state: 'on',
+          attributes: {
+            title: 'Incomplete',
+            // Missing installed_version and latest_version
+          },
+          last_changed: '2026-01-08T10:00:00.000Z',
+          last_updated: '2026-01-08T10:00:00.000Z',
+          context: { id: 'ctx-1', parent_id: null, user_id: null },
+        },
+      ]);
+
+      const result = await updateOps.getAvailableUpdates();
+
+      // Should not include entities without version info
+      expect(result.updates).toEqual([]);
+    });
+
+    it('should use title or friendly_name for name', async () => {
+      (mockEntityOps.getEntitiesByDomain as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          entity_id: 'update.with_title',
+          state: 'on',
+          attributes: {
+            title: 'Title Name',
+            friendly_name: 'Friendly Name',
+            installed_version: '1.0',
+            latest_version: '2.0',
+          },
+          last_changed: '2026-01-08T10:00:00.000Z',
+          last_updated: '2026-01-08T10:00:00.000Z',
+          context: { id: 'ctx-1', parent_id: null, user_id: null },
+        },
+      ]);
+
+      const result = await updateOps.getAvailableUpdates();
+
+      expect(result.updates[0].name).toBe('Title Name');
+    });
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Index/Main entry point tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { EnvironmentConfig } from '../src/config.js';
+
+describe('Main entry point', () => {
+  describe('Configuration loading', () => {
+    it('should require baseUrl and token', () => {
+      const validConfig: EnvironmentConfig = {
+        baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        token: 'test-token',
+        strictSsl: false,
+        timeout: 30000,
+        aiProvider: 'ollama',
+        aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+        aiModel: 'qwen3:14b',
+        aiTimeout: 60000,
+        logLevel: 'info',
+        logFormat: 'plain',
+        useHttp: false,
+        stateful: false,
+        httpTransport: 'stream',
+        httpEnableHealthcheck: true,
+        httpAllowCors: true,
+      };
+
+      expect(validConfig.baseUrl).toBeDefined();
+      expect(validConfig.token).toBeDefined();
+    });
+  });
+
+  describe('Logger initialization', () => {
+    it('should use stderr in stdio mode to avoid MCP protocol interference', () => {
+      const stdioConfig = {
+        useHttp: false,
+      };
+
+      const useStderr = !stdioConfig.useHttp;
+      expect(useStderr).toBe(true);
+    });
+
+    it('should use stdout in HTTP mode', () => {
+      const httpConfig = {
+        useHttp: true,
+      };
+
+      const useStderr = !httpConfig.useHttp;
+      expect(useStderr).toBe(false);
+    });
+  });
+
+  describe('Server mode selection', () => {
+    it('should start stdio server when useHttp is false', () => {
+      const config = {
+        useHttp: false,
+      };
+
+      expect(config.useHttp).toBe(false);
+      // Would call startStdioServer
+    });
+
+    it('should start HTTP server when useHttp is true', () => {
+      const config = {
+        useHttp: true,
+      };
+
+      expect(config.useHttp).toBe(true);
+      // Would call startHttpServer
+    });
+  });
+
+  describe('Configuration logging', () => {
+    it('should log configuration without exposing token', () => {
+      const config = {
+        baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        token: 'super-secret-token',
+        strictSsl: false,
+        timeout: 30000,
+        useHttp: false,
+      };
+
+      // Log data should mask the token
+      const logData = {
+        baseUrl: config.baseUrl,
+        hasToken: !!config.token,
+        strictSsl: config.strictSsl,
+        timeout: config.timeout,
+        useHttp: config.useHttp,
+      };
+
+      expect(logData.hasToken).toBe(true);
+      expect(logData).not.toHaveProperty('token');
+      expect(JSON.stringify(logData)).not.toContain('super-secret-token');
+    });
+
+    it('should include transport type in HTTP mode logs', () => {
+      const config = {
+        useHttp: true,
+        httpTransport: 'stream',
+      };
+
+      const logData = {
+        useHttp: config.useHttp,
+        httpTransport: config.useHttp ? config.httpTransport : undefined,
+      };
+
+      expect(logData.httpTransport).toBe('stream');
+    });
+
+    it('should not include transport type in stdio mode logs', () => {
+      const config = {
+        useHttp: false,
+        httpTransport: 'stream',
+      };
+
+      const logData = {
+        useHttp: config.useHttp,
+        httpTransport: config.useHttp ? config.httpTransport : undefined,
+      };
+
+      expect(logData.httpTransport).toBeUndefined();
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should set exit code on configuration error', () => {
+      let exitCode: number | undefined;
+
+      try {
+        throw new Error('Invalid configuration');
+      } catch (error) {
+        exitCode = 1;
+      }
+
+      expect(exitCode).toBe(1);
+    });
+
+    it('should set exit code on API connection error', () => {
+      let exitCode: number | undefined;
+
+      try {
+        throw new Error('Connection failed');
+      } catch (error) {
+        exitCode = 1;
+      }
+
+      expect(exitCode).toBe(1);
+    });
+
+    it('should set exit code on server start error', () => {
+      let exitCode: number | undefined;
+
+      try {
+        throw new Error('Server start failed');
+      } catch (error) {
+        exitCode = 1;
+      }
+
+      expect(exitCode).toBe(1);
+    });
+  });
+});

package/tests/localAI/index.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the providers before importing LocalAIClient
+const mockOllamaAnalyze = vi.fn();
+const mockOllamaHealth = vi.fn();
+const mockOpenAIAnalyze = vi.fn();
+const mockOpenAIHealth = vi.fn();
+
+vi.mock('../../src/localAI/providers/ollama.js', () => ({
+  OllamaProvider: vi.fn().mockImplementation(() => ({
+    analyzeSensors: mockOllamaAnalyze,
+    checkHealth: mockOllamaHealth,
+    getProviderName: () => 'ollama',
+  })),
+}));
+
+vi.mock('../../src/localAI/providers/openai.js', () => ({
+  OpenAICompatibleProvider: vi.fn().mockImplementation(() => ({
+    analyzeSensors: mockOpenAIAnalyze,
+    checkHealth: mockOpenAIHealth,
+    getProviderName: () => 'openai-compatible',
+  })),
+}));
+
+import { LocalAIClient } from '../../src/localAI/index.js';
+import type { EnvironmentConfig } from '../../src/config.js';
+import type { AIProviderType } from '../../src/localAI/types.js';
+
+describe('LocalAIClient', () => {
+  const createConfig = (provider: AIProviderType = 'ollama'): EnvironmentConfig =>
+    ({
+      aiProvider: provider,
+      aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+      aiModel: 'qwen3:14b',
+      aiTimeout: 60000,
+      aiApiKey: undefined,
+      // Other required config fields
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      token: 'test-token',
+      strictSsl: true,
+      timeout: 30000,
+      logLevel: 'info',
+      logFormat: 'plain',
+      useHttp: false,
+      stateful: false,
+      httpTransport: 'stream',
+      httpEnableHealthcheck: true,
+      httpAllowCors: true,
+    }) as EnvironmentConfig;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create OllamaProvider for ollama provider type', () => {
+      const config = createConfig('ollama');
+      const client = new LocalAIClient(config);
+
+      expect(client.getProviderName()).toBe('ollama');
+    });
+
+    it('should create OpenAICompatibleProvider for openai provider type', () => {
+      const config = createConfig('openai');
+      const client = new LocalAIClient(config);
+
+      expect(client.getProviderName()).toBe('openai-compatible');
+    });
+
+    it('should default to OllamaProvider when provider is unknown', () => {
+      const config = createConfig('ollama');
+      // Force unknown provider
+      (config as unknown as { aiProvider: string }).aiProvider = 'unknown';
+      const client = new LocalAIClient(config);
+
+      // Should fall back to ollama
+      expect(client.getProviderName()).toBe('ollama');
+    });
+  });
+
+  describe('analyzeSensors', () => {
+    it('should delegate to the provider', async () => {
+      const mockResult = {
+        severity: 'critical' as const,
+        issue: 'Test issue',
+        reasoning: 'Test reasoning',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.9,
+        model: 'qwen3:14b',
+        provider: 'ollama',
+        response_time: 1.5,
+      };
+      mockOllamaAnalyze.mockResolvedValueOnce(mockResult);
+
+      const config = createConfig('ollama');
+      const client = new LocalAIClient(config);
+      const sensors = { 'sensor.test': { state: '25' } };
+
+      const result = await client.analyzeSensors(sensors);
+
+      expect(mockOllamaAnalyze).toHaveBeenCalledWith(sensors);
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe('checkHealth', () => {
+    it('should delegate to the provider', async () => {
+      mockOllamaHealth.mockResolvedValueOnce(true);
+
+      const config = createConfig('ollama');
+      const client = new LocalAIClient(config);
+
+      const result = await client.checkHealth();
+
+      expect(mockOllamaHealth).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it('should return false when provider is unhealthy', async () => {
+      mockOllamaHealth.mockResolvedValueOnce(false);
+
+      const config = createConfig('ollama');
+      const client = new LocalAIClient(config);
+
+      const result = await client.checkHealth();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getModelName', () => {
+    it('should return the configured model name', () => {
+      const config = createConfig('ollama');
+      config.aiModel = 'phi4:14b';
+      const client = new LocalAIClient(config);
+
+      expect(client.getModelName()).toBe('phi4:14b');
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return the provider configuration', () => {
+      const config = createConfig('ollama');
+      config.aiApiKey = 'test-key';
+      const client = new LocalAIClient(config);
+
+      const providerConfig = client.getConfig();
+
+      expect(providerConfig.provider).toBe('ollama');
+      expect(providerConfig.baseUrl).toBe('http://ollama.10.0.0.17.nip.io:11434');
+      expect(providerConfig.model).toBe('qwen3:14b');
+      expect(providerConfig.timeout).toBe(60000);
+      expect(providerConfig.apiKey).toBe('test-key');
+    });
+
+    it('should return a copy of the config (immutable)', () => {
+      const config = createConfig('ollama');
+      const client = new LocalAIClient(config);
+
+      const providerConfig1 = client.getConfig();
+      const providerConfig2 = client.getConfig();
+
+      expect(providerConfig1).not.toBe(providerConfig2);
+      expect(providerConfig1).toEqual(providerConfig2);
+    });
+  });
+});