@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/integration/homeassistant.test.ts

@@ -1,144 +0,0 @@
-/**
- * Integration tests for Home Assistant
- * These tests run against a real Home Assistant instance
- * Requires HA_URL and HA_TOKEN environment variables
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { HaClient } from '../../src/haClient/index.js';
-
-describe('Home Assistant Integration', () => {
-  let client: HaClient;
-
-  beforeAll(() => {
-    const baseUrl = process.env.HA_URL;
-    const token = process.env.HA_TOKEN;
-
-    if (!baseUrl || !token) {
-      throw new Error('HA_URL and HA_TOKEN environment variables are required for integration tests');
-    }
-
-    client = new HaClient({
-      baseUrl,
-      token,
-      strictSsl: process.env.HA_STRICT_SSL !== 'false',
-      timeout: parseInt(process.env.HA_TIMEOUT || '30000'),
-    });
-  });
-
-  describe('API Connection', () => {
-    it('should connect to Home Assistant API', async () => {
-      const result = await client.checkApi();
-      expect(result.message).toBe('API running.');
-    });
-
-    it('should get Home Assistant version', async () => {
-      const version = await client.getVersion();
-      expect(version).toHaveProperty('version');
-      expect(version.version).toMatch(/^\d+\.\d+\.\d+/);
-    });
-  });
-
-  describe('Entity States', () => {
-    it('should get all states', async () => {
-      const states = await client.getStates();
-      expect(Array.isArray(states)).toBe(true);
-      expect(states.length).toBeGreaterThan(0);
-    });
-
-    it('should get state of a specific entity', async () => {
-      // First get all states to find a valid entity_id
-      const states = await client.getStates();
-      expect(states.length).toBeGreaterThan(0);
-
-      const entity = await client.getState(states[0].entity_id);
-      expect(entity).not.toBeNull();
-      expect(entity).toHaveProperty('entity_id');
-      expect(entity).toHaveProperty('state');
-      expect(entity).toHaveProperty('attributes');
-    });
-  });
-
-  describe('Entity Search', () => {
-    it('should search entities by query', async () => {
-      const results = await client.searchEntities('sensor');
-      expect(Array.isArray(results)).toBe(true);
-    });
-  });
-
-  describe('Domain Operations', () => {
-    it('should get entities by domain', async () => {
-      const entities = await client.getEntitiesByDomain('sensor');
-      expect(Array.isArray(entities)).toBe(true);
-      entities.forEach((entity) => {
-        expect(entity.entity_id).toMatch(/^sensor\./);
-      });
-    });
-
-    it('should get domain summary', async () => {
-      const result = await client.getDomainSummary('sensor');
-      expect(result).toHaveProperty('domain');
-      expect(result).toHaveProperty('count');
-      expect(result).toHaveProperty('states');
-      expect(result.domain).toBe('sensor');
-      expect(result.count).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Sensors', () => {
-    it('should get all sensors', async () => {
-      const sensors = await client.getAllSensors();
-      expect(Array.isArray(sensors)).toBe(true);
-      sensors.forEach((entity) => {
-        expect(entity.entity_id).toMatch(/^(sensor|binary_sensor)\./);
-      });
-    });
-  });
-
-  describe('Persons', () => {
-    it('should get person entities via domain lookup', async () => {
-      // The HaClient doesn't have a getPersons method directly
-      // Persons are accessed via getEntitiesByDomain('person')
-      const persons = await client.getEntitiesByDomain('person');
-      expect(Array.isArray(persons)).toBe(true);
-      persons.forEach((person) => {
-        expect(person.entity_id).toMatch(/^person\./);
-      });
-    });
-  });
-
-  describe('Automations', () => {
-    it('should list automations', async () => {
-      const result = await client.getAutomations();
-      expect(Array.isArray(result)).toBe(true);
-      if (result.length > 0) {
-        // Automation type uses 'id' not 'entity_id'
-        expect(result[0]).toHaveProperty('id');
-        expect(result[0]).toHaveProperty('state');
-        expect(result[0]).toHaveProperty('alias');
-      }
-    });
-  });
-
-  describe('Calendars', () => {
-    it('should list calendars (or report the integration absent)', async () => {
-      // HA only serves /api/calendars when a calendar integration is loaded;
-      // a bare instance 404s. Both are valid live-system states — the test
-      // asserts the client surfaces them correctly, not that the user has
-      // calendars configured.
-      try {
-        const result = await client.getCalendars();
-        expect(Array.isArray(result)).toBe(true);
-      } catch (error) {
-        expect((error as { statusCode?: number; message: string }).message).toMatch(/Not Found/i);
-      }
-    });
-  });
-
-  describe('System', () => {
-    it('should get system log', async () => {
-      const result = await client.getSystemLog({ hours: 1, limit: 10 });
-      expect(Array.isArray(result)).toBe(true);
-    });
-  });
-});

package/tests/integration/omada.test.ts

@@ -1,167 +0,0 @@
-/**
- * Integration tests for TP-Link Omada Controller
- * These tests run against a real Omada controller
- * Requires OMADA_* environment variables
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { OmadaClient } from '../../src/omadaClient/index.js';
-
-describe('Omada Integration', () => {
-  let client: OmadaClient;
-  let siteId: string;
-
-  beforeAll(async () => {
-    const baseUrl = process.env.OMADA_BASE_URL;
-    const clientId = process.env.OMADA_CLIENT_ID;
-    const clientSecret = process.env.OMADA_CLIENT_SECRET;
-    const omadacId = process.env.OMADA_OMADAC_ID;
-
-    if (!baseUrl || !clientId || !clientSecret || !omadacId) {
-      throw new Error('OMADA_BASE_URL, OMADA_CLIENT_ID, OMADA_CLIENT_SECRET, and OMADA_OMADAC_ID are required');
-    }
-
-    client = new OmadaClient({
-      baseUrl,
-      clientId,
-      clientSecret,
-      omadacId,
-      siteId: process.env.OMADA_SITE_ID,
-      strictSsl: process.env.OMADA_STRICT_SSL !== 'false',
-      timeout: parseInt(process.env.OMADA_TIMEOUT || '30000'),
-    });
-
-    // Get siteId for tests
-    siteId = process.env.OMADA_SITE_ID || '';
-  });
-
-  describe('Sites', () => {
-    it('should list all sites', async () => {
-      const sites = await client.listSites();
-      expect(Array.isArray(sites)).toBe(true);
-      expect(sites.length).toBeGreaterThan(0);
-      expect(sites[0]).toHaveProperty('siteId');
-      expect(sites[0]).toHaveProperty('name');
-
-      // Use first site if not configured
-      if (!siteId) {
-        siteId = sites[0].siteId;
-      }
-    });
-  });
-
-  describe('Devices', () => {
-    it('should list network devices', async () => {
-      const devices = await client.listDevices(siteId);
-      expect(Array.isArray(devices)).toBe(true);
-      if (devices.length > 0) {
-        expect(devices[0]).toHaveProperty('mac');
-        expect(devices[0]).toHaveProperty('name');
-        expect(devices[0]).toHaveProperty('type');
-        expect(devices[0]).toHaveProperty('ip');
-      }
-    });
-
-    it('should search devices globally', async () => {
-      // searchDevices returns an array of OmadaDeviceInfo
-      // Note: If no devices match, the API may return an empty object {} instead of []
-      // so we need to handle both cases
-      const results = await client.searchDevices('gateway');
-      // Results could be an array or an empty object if no matches
-      const isArrayOrEmpty = Array.isArray(results) || (typeof results === 'object' && results !== null);
-      expect(isArrayOrEmpty).toBe(true);
-      if (Array.isArray(results) && results.length > 0) {
-        expect(results[0]).toHaveProperty('mac');
-      }
-    });
-  });
-
-  describe('Clients', () => {
-    it('should list connected clients', async () => {
-      const clients = await client.listClients(siteId);
-      expect(Array.isArray(clients)).toBe(true);
-      if (clients.length > 0) {
-        expect(clients[0]).toHaveProperty('mac');
-        expect(clients[0]).toHaveProperty('ip');
-      }
-    });
-
-    it('should list most active clients', async () => {
-      const clients = await client.listMostActiveClients(siteId);
-      expect(Array.isArray(clients)).toBe(true);
-      if (clients.length > 0) {
-        expect(clients[0]).toHaveProperty('name');
-        // Controller v5 exposed `totalTraffic`; OC200 v6 renamed the traffic
-        // field. Assert a traffic-ish field exists rather than pinning the
-        // v5 name (discovered live on OC200 6.2, 2026-07-11).
-        const keys = Object.keys(clients[0] as Record<string, unknown>);
-        expect(keys.some((k) => /traffic|activity/i.test(k))).toBe(true);
-      }
-    });
-  });
-
-  describe('Network Configuration', () => {
-    it('should get internet info', async () => {
-      const info = await client.getInternetInfo(siteId);
-      expect(info).toHaveProperty('wanPortSettings');
-    });
-
-    it('should get LAN network list', async () => {
-      const networks = await client.getLanNetworkList(siteId);
-      expect(Array.isArray(networks)).toBe(true);
-      if (networks.length > 0) {
-        expect(networks[0]).toHaveProperty('name');
-        expect(networks[0]).toHaveProperty('vlan');
-      }
-    });
-
-    it('should get WLAN group list', async () => {
-      const groups = await client.getWlanGroupList(siteId);
-      expect(Array.isArray(groups)).toBe(true);
-    });
-  });
-
-  describe('Rate Limiting', () => {
-    it('should get rate limit profiles', async () => {
-      const profiles = await client.getRateLimitProfiles(siteId);
-      expect(Array.isArray(profiles)).toBe(true);
-      if (profiles.length > 0) {
-        expect(profiles[0]).toHaveProperty('profileId');
-        expect(profiles[0]).toHaveProperty('name');
-      }
-    });
-  });
-
-  describe('Security', () => {
-    it('should get threat list (may be empty)', async () => {
-      // The threat list API may return 400 if IDS/IPS is not enabled or configured
-      // This test catches the error and passes if no threats are available.
-      // NB: archived/page/pageSize/startTime/endTime are REQUIRED — controller
-      // v5 tolerated their absence, OC200 v6 rejects nulls ("archived should
-      // not be null", live finding 2026-07-11). The MCP tool schema already
-      // requires them; this test used to cheat with `{}`.
-      try {
-        const now = Math.floor(Date.now() / 1000);
-        const result = await client.getThreatList({
-          archived: false,
-          page: 1,
-          pageSize: 10,
-          startTime: now - 7 * 24 * 3600,
-          endTime: now,
-        });
-        // If we get here, the API worked - check structure
-        expect(result).toHaveProperty('data');
-        expect(Array.isArray(result.data)).toBe(true);
-      } catch (error) {
-        // Some Omada setups may not have threat detection enabled
-        // This is acceptable - skip rather than fail
-        if (error instanceof Error && error.message.includes('400')) {
-          // API returned 400 - threat detection may not be enabled
-          expect(true).toBe(true);
-        } else {
-          throw error;
-        }
-      }
-    });
-  });
-});

package/tests/integration/server.test.ts

@@ -1,151 +0,0 @@
-/**
- * Integration tests for MCP Server
- * Tests server initialization with real clients
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { HaClient } from '../../src/haClient/index.js';
-import { OmadaClient } from '../../src/omadaClient/index.js';
-import { createServer } from '../../src/server/common.js';
-import { generateInstructions } from '../../src/server/instructions.js';
-
-describe('Server Integration', () => {
-  let haClient: HaClient | undefined;
-  let omadaClient: OmadaClient | undefined;
-
-  beforeAll(async () => {
-    // Initialize HA client if configured
-    if (process.env.HA_URL && process.env.HA_TOKEN) {
-      haClient = new HaClient({
-        baseUrl: process.env.HA_URL,
-        token: process.env.HA_TOKEN,
-        strictSsl: process.env.HA_STRICT_SSL !== 'false',
-        timeout: parseInt(process.env.HA_TIMEOUT || '30000'),
-      });
-    }
-
-    // Initialize Omada client if configured
-    if (
-      process.env.OMADA_BASE_URL &&
-      process.env.OMADA_CLIENT_ID &&
-      process.env.OMADA_CLIENT_SECRET &&
-      process.env.OMADA_OMADAC_ID
-    ) {
-      omadaClient = new OmadaClient({
-        baseUrl: process.env.OMADA_BASE_URL,
-        clientId: process.env.OMADA_CLIENT_ID,
-        clientSecret: process.env.OMADA_CLIENT_SECRET,
-        omadacId: process.env.OMADA_OMADAC_ID,
-        siteId: process.env.OMADA_SITE_ID,
-        strictSsl: process.env.OMADA_STRICT_SSL !== 'false',
-        timeout: parseInt(process.env.OMADA_TIMEOUT || '30000'),
-      });
-    }
-  });
-
-  describe('Server Creation', () => {
-    it('should create server with HA client', () => {
-      if (!haClient) {
-        console.log('Skipping: HA not configured');
-        return;
-      }
-
-      const server = createServer({ haClient });
-      expect(server).toBeDefined();
-      expect(server.server).toBeDefined();
-    });
-
-    it('should create server with Omada client', () => {
-      if (!omadaClient) {
-        console.log('Skipping: Omada not configured');
-        return;
-      }
-
-      const server = createServer({ omadaClient });
-      expect(server).toBeDefined();
-    });
-
-    it('should create server with all clients', () => {
-      const server = createServer({
-        haClient,
-        omadaClient,
-      });
-      expect(server).toBeDefined();
-    });
-  });
-
-  describe('Server Instructions', () => {
-    it('should generate instructions for HA only', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: false,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('MCP-HA-Connect');
-      expect(instructions).toContain('ENTITY QUERIES');
-      expect(instructions).not.toContain('OMADA');
-    });
-
-    it('should generate instructions for Omada only', () => {
-      const instructions = generateInstructions({
-        haEnabled: false,
-        omadaEnabled: true,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('MCP-HA-Connect');
-      expect(instructions).toContain('OMADA');
-      expect(instructions).not.toContain('ENTITY QUERIES');
-    });
-
-    it('should generate instructions for all plugins', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: true,
-      });
-
-      expect(instructions).toContain('MCP-HA-Connect');
-      expect(instructions).toContain('ENTITY QUERIES');
-      expect(instructions).toContain('OMADA');
-      expect(instructions).toContain('AI ANALYSIS');
-      expect(instructions).toContain('INTEGRATION');
-    });
-
-    it('should generate concise instructions under the size ceiling', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: true,
-      });
-
-      // Keep in sync with tests/server/instructions.test.ts — the ceiling was
-      // raised 2000 -> 2200 in v1.6.0 (ACTIONS line); this integration twin was
-      // stale until the suite was actually run (2026-07-11).
-      expect(instructions.length).toBeLessThan(2200);
-    });
-  });
-
-  describe('Client Connectivity', () => {
-    it('should verify HA connection', async () => {
-      if (!haClient) {
-        console.log('Skipping: HA not configured');
-        return;
-      }
-
-      const result = await haClient.checkApi();
-      expect(result.message).toBe('API running.');
-    });
-
-    it('should verify Omada connection', async () => {
-      if (!omadaClient) {
-        console.log('Skipping: Omada not configured');
-        return;
-      }
-
-      const sites = await omadaClient.listSites();
-      expect(sites.length).toBeGreaterThan(0);
-    });
-  });
-});

package/tests/localAI/index.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { EnvironmentConfig } from '../../src/config.js';
-import type { AIProviderType } from '../../src/localAI/types.js';
-
-// Create mock functions that will be used by the mock implementations
-const mockOllamaAnalyze = vi.fn();
-const mockOllamaHealth = vi.fn();
-const mockOpenAIAnalyze = vi.fn();
-const mockOpenAIHealth = vi.fn();
-
-// Mock the providers with class-style constructors
-vi.mock('../../src/localAI/providers/ollama.js', () => {
-  return {
-    OllamaProvider: class MockOllamaProvider {
-      analyzeSensors = mockOllamaAnalyze;
-      checkHealth = mockOllamaHealth;
-      getProviderName() {
-        return 'ollama';
-      }
-    },
-  };
-});
-
-vi.mock('../../src/localAI/providers/openai.js', () => {
-  return {
-    OpenAICompatibleProvider: class MockOpenAIProvider {
-      analyzeSensors = mockOpenAIAnalyze;
-      checkHealth = mockOpenAIHealth;
-      getProviderName() {
-        return 'openai-compatible';
-      }
-    },
-  };
-});
-
-import { LocalAIClient } from '../../src/localAI/index.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,
-      
-      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);
-    });
-  });
-});