@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/server/instructions.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateInstructions } from '../../src/server/instructions.js';
-
-describe('Server Instructions', () => {
-  describe('generateInstructions', () => {
-    it('should generate base instructions when no plugins enabled', () => {
-      const instructions = generateInstructions({
-        haEnabled: false,
-        omadaEnabled: false,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('MCP-HA-Connect');
-      expect(instructions).not.toContain('ENTITY QUERIES');
-      expect(instructions).not.toContain('OMADA');
-      expect(instructions).not.toContain('AI ANALYSIS');
-    });
-
-    it('should include HA instructions when haEnabled is true', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: false,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('ENTITY QUERIES');
-      expect(instructions).toContain('paginated');
-      expect(instructions).toContain('includeAttributes');
-      expect(instructions).toContain('listPersons');
-      expect(instructions).toContain('CONTROL');
-      expect(instructions).toContain('controlLight');
-      expect(instructions).toContain('AUTOMATIONS');
-      expect(instructions).toContain('NOTIFICATIONS');
-      expect(instructions).toContain('listNotificationTargets');
-    });
-
-    it('should include Omada instructions when omadaEnabled is true', () => {
-      const instructions = generateInstructions({
-        haEnabled: false,
-        omadaEnabled: true,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('OMADA');
-      expect(instructions).toContain('siteId');
-      expect(instructions).toContain('omada_listSites');
-      expect(instructions).toContain('CLIENTS vs DEVICES');
-      expect(instructions).toContain('omada_listClients');
-      expect(instructions).toContain('omada_listDevices');
-      expect(instructions).toContain('RATE LIMITS');
-      expect(instructions).toContain('SAFETY');
-    });
-
-    it('should include AI instructions when aiEnabled is true', () => {
-      const instructions = generateInstructions({
-        haEnabled: false,
-        omadaEnabled: false,
-        aiEnabled: true,
-      });
-
-      expect(instructions).toContain('AI ANALYSIS');
-      expect(instructions).toContain('analyzeSensors');
-      expect(instructions).toContain('Ollama');
-    });
-
-    it('should include cross-plugin instructions when both HA and Omada enabled', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: false,
-      });
-
-      expect(instructions).toContain('INTEGRATION');
-      expect(instructions).toContain('device_trackers');
-      expect(instructions).toContain('presence detection');
-    });
-
-    it('should not include cross-plugin instructions when only one plugin enabled', () => {
-      const haOnly = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: false,
-        aiEnabled: false,
-      });
-
-      const omadaOnly = generateInstructions({
-        haEnabled: false,
-        omadaEnabled: true,
-        aiEnabled: false,
-      });
-
-      expect(haOnly).not.toContain('INTEGRATION');
-      expect(omadaOnly).not.toContain('INTEGRATION');
-    });
-
-    it('should include all sections when all plugins enabled', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: true,
-      });
-
-      // Base
-      expect(instructions).toContain('MCP-HA-Connect');
-
-      // HA
-      expect(instructions).toContain('ENTITY QUERIES');
-      expect(instructions).toContain('STATE');
-      expect(instructions).toContain('CONTROL');
-      expect(instructions).toContain('AUTOMATIONS');
-      expect(instructions).toContain('NOTIFICATIONS');
-
-      // Omada
-      expect(instructions).toContain('OMADA');
-      expect(instructions).toContain('CLIENTS vs DEVICES');
-      expect(instructions).toContain('RATE LIMITS');
-      expect(instructions).toContain('SAFETY');
-
-      // AI
-      expect(instructions).toContain('AI ANALYSIS');
-
-      // Cross-plugin
-      expect(instructions).toContain('INTEGRATION');
-    });
-
-    it('should return a single string with space-separated sections', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: true,
-      });
-
-      // Should be a single string, not contain newlines
-      expect(typeof instructions).toBe('string');
-      expect(instructions).not.toContain('\n');
-    });
-
-    it('should produce reasonably sized instructions', () => {
-      const instructions = generateInstructions({
-        haEnabled: true,
-        omadaEnabled: true,
-        aiEnabled: true,
-      });
-
-      // Instructions should be concise - ceiling raised 2000 -> 2200 for the v1.6
-      // ACTIONS line (PoE cycle + SSID toggle); still deliberately tight so the
-      // budget keeps pushing back on instruction creep.
-      expect(instructions.length).toBeLessThan(2200);
-      // But substantial enough to be useful - at least 500 chars with all plugins
-      expect(instructions.length).toBeGreaterThan(500);
-    });
-  });
-});

package/tests/server/memoizeJsonSchema.test.ts

@@ -1,71 +0,0 @@
-/**
- * memoizeJsonSchema: each tool schema is converted to JSON Schema once per process,
- * not once per (stateless) request — without changing the result or validation.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { z } from 'zod';
-import { memoizeJsonSchema, isJsonSchemaMemoized, createServer } from '../../src/server/common.js';
-import { controlLightSchema } from '../../src/tools/common.js';
-
-type Std = {
-  validate: (v: unknown) => unknown;
-  jsonSchema: { input: (o?: unknown) => Record<string, unknown>; output: (o?: unknown) => Record<string, unknown> };
-};
-const std = (s: unknown): Std => (s as { '~standard': Std })['~standard'];
-
-describe('memoizeJsonSchema', () => {
-  it('converts once per schema and options, then serves the cache', () => {
-    const schema = z.object({ a: z.string().describe('A') });
-    const convert = vi.spyOn(std(schema).jsonSchema, 'input');
-    memoizeJsonSchema(schema);
-
-    const opts = { target: 'draft-2020-12' };
-    const first = std(schema).jsonSchema.input(opts);
-    const second = std(schema).jsonSchema.input(opts);
-    expect(convert).toHaveBeenCalledTimes(1);
-    expect(second).toEqual(first);
-  });
-
-  it('returns an independent copy each time, so a caller mutating it cannot corrupt the cache', () => {
-    const schema = z.object({ a: z.string() });
-    memoizeJsonSchema(schema);
-    const first = std(schema).jsonSchema.input({ target: 'draft-2020-12' });
-    (first as { properties: Record<string, unknown> }).properties.injected = { type: 'string' };
-    const second = std(schema).jsonSchema.input({ target: 'draft-2020-12' });
-    expect(second).not.toHaveProperty('properties.injected');
-  });
-
-  it('produces exactly what the un-memoized converter produces', () => {
-    const reference = std(z.object({ entity_id: z.string().describe('id'), n: z.number().int().min(1).optional() }))
-      .jsonSchema.input({ target: 'draft-2020-12' });
-    const schema = z.object({ entity_id: z.string().describe('id'), n: z.number().int().min(1).optional() });
-    memoizeJsonSchema(schema);
-    expect(std(schema).jsonSchema.input({ target: 'draft-2020-12' })).toEqual(reference);
-  });
-
-  it('leaves validation untouched', () => {
-    const schema = z.object({ a: z.string() });
-    memoizeJsonSchema(schema);
-    expect(schema.safeParse({ a: 'ok' }).success).toBe(true);
-    expect(schema.safeParse({ a: 1 }).success).toBe(false);
-    expect(std(schema).validate({ a: 1 })).toHaveProperty('issues');
-  });
-
-  it('ignores values that are not converter-carrying schemas', () => {
-    expect(() => memoizeJsonSchema(undefined)).not.toThrow();
-    expect(() => memoizeJsonSchema({ shape: 'raw' })).not.toThrow();
-  });
-
-  it('is applied by createServer to every registered tool schema', () => {
-    // (An own `~standard` property is NOT proof: zod defines it lazily on first read,
-    // which the SDK does anyway. The memo's own membership set is the real signal.)
-    expect(isJsonSchemaMemoized(controlLightSchema)).toBe(false);
-    createServer({ haClient: {} as never });
-    expect(isJsonSchemaMemoized(controlLightSchema)).toBe(true);
-    // Later per-request builds reuse the same cached provider (no re-wrapping).
-    const provider = std(controlLightSchema);
-    createServer({ haClient: {} as never });
-    expect(std(controlLightSchema)).toBe(provider);
-  });
-});

package/tests/server/stdio.test.ts

@@ -1,99 +0,0 @@
-/**
- * Stdio server tests
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Mock dependencies
-vi.mock('../../src/server/common.js');
-vi.mock('@modelcontextprotocol/server/stdio', () => ({
-  StdioServerTransport: class MockStdioServerTransport {},
-}));
-vi.mock('../../src/utils/logger.js');
-
-describe('startStdioServer', () => {
-  let mockClient: any;
-  let startStdioServer: any;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    vi.resetModules();
-
-    // Mock HaClient
-    mockClient = {
-      checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
-      getStates: vi.fn(),
-      getState: vi.fn(),
-      callService: vi.fn(),
-      getEntitiesByDomain: vi.fn(),
-      searchEntities: vi.fn(),
-    };
-
-    // Import the function to test
-    const stdioModule = await import('../../src/server/stdio.js');
-    startStdioServer = stdioModule.startStdioServer;
-  });
-
-  it('should create and start stdio server', async () => {
-    const { createServer } = await import('../../src/server/common.js');
-    const { StdioServerTransport } = await import('@modelcontextprotocol/server/stdio');
-
-    const mockServer = {
-      connect: vi.fn().mockResolvedValue(undefined),
-    };
-    vi.mocked(createServer).mockReturnValue(mockServer as any);
-
-    await startStdioServer({ haClient: mockClient });
-
-    expect(createServer).toHaveBeenCalledWith({
-      haClient: mockClient,
-      omadaClient: undefined,
-      aiClient: undefined,
-    });
-    expect(mockServer.connect).toHaveBeenCalled();
-  });
-
-  it('should log server startup', async () => {
-    const { logger } = await import('../../src/utils/logger.js');
-    const { createServer } = await import('../../src/server/common.js');
-
-    const mockServer = {
-      connect: vi.fn().mockResolvedValue(undefined),
-    };
-    vi.mocked(createServer).mockReturnValue(mockServer as any);
-
-    await startStdioServer({ haClient: mockClient });
-
-    expect(logger.info).toHaveBeenCalledWith('Starting stdio server');
-    expect(logger.info).toHaveBeenCalledWith('Connecting stdio server');
-    expect(logger.info).toHaveBeenCalledWith('Stdio server connected and ready');
-  });
-
-  it('should handle connection errors', async () => {
-    const { createServer } = await import('../../src/server/common.js');
-
-    const mockServer = {
-      connect: vi.fn().mockRejectedValue(new Error('Connection failed')),
-    };
-    vi.mocked(createServer).mockReturnValue(mockServer as any);
-
-    await expect(startStdioServer({ haClient: mockClient })).rejects.toThrow('Connection failed');
-  });
-
-  it('should work without haClient (Omada-only mode)', async () => {
-    const { createServer } = await import('../../src/server/common.js');
-
-    const mockServer = {
-      connect: vi.fn().mockResolvedValue(undefined),
-    };
-    vi.mocked(createServer).mockReturnValue(mockServer as any);
-
-    await startStdioServer({});
-
-    expect(createServer).toHaveBeenCalledWith({
-      haClient: undefined,
-      omadaClient: undefined,
-      aiClient: undefined,
-    });
-  });
-});

package/tests/server/stream.test.ts

@@ -1,285 +0,0 @@
-/**
- * Streamable HTTP transport tests
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { HaClient } from '../../src/haClient/index.js';
-import type { EnvironmentConfig } from '../../src/config.js';
-
-// Mock dependencies
-vi.mock('../../src/server/common.js');
-vi.mock('../../src/utils/logger.js');
-
-describe('Stream Transport', () => {
-  let mockClient: HaClient;
-  let mockConfig: EnvironmentConfig;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockClient = {
-      checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
-      getStates: vi.fn(),
-      getState: vi.fn(),
-      callService: vi.fn(),
-      getEntitiesByDomain: vi.fn(),
-      searchEntities: vi.fn(),
-    } as any;
-
-    mockConfig = {
-      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: true,
-      stateful: false,
-      httpPort: 3000,
-      
-      httpBindAddr: '127.0.0.1',
-      httpPath: '/mcp',
-      httpEnableHealthcheck: true,
-      httpHealthcheckPath: '/health',
-      httpAllowCors: true,
-      httpAllowedOrigins: ['127.0.0.1', 'localhost'],
-    };
-  });
-
-  describe('Stream Connection', () => {
-    it('should create streamable HTTP transport', () => {
-      expect(mockConfig.httpPath).toBe('/mcp');
-    });
-
-    it('should support stateless mode by default', () => {
-      expect(mockConfig.stateful).toBe(false);
-      // Each request creates a new transport
-    });
-
-    it('should support stateful mode when enabled', () => {
-      const statefulConfig = { ...mockConfig, stateful: true };
-
-      expect(statefulConfig.stateful).toBe(true);
-      // Reuses existing transport for session
-    });
-
-    it('should use modern MCP protocol version', () => {
-      const protocolVersion = '2025-03-26';
-
-      expect(protocolVersion).toBe('2025-03-26');
-      // This is the modern streamable HTTP protocol version
-    });
-  });
-
-  describe('Request Handling', () => {
-    it('should handle GET requests', () => {
-      const method = 'GET';
-
-      expect(method).toBe('GET');
-      // Stream transport supports GET for initial connection
-    });
-
-    it('should handle POST requests', () => {
-      const method = 'POST';
-
-      expect(method).toBe('POST');
-      // Stream transport supports POST for messages
-    });
-
-    it('should parse request body for non-GET requests', () => {
-      const method: string = 'POST';
-      const shouldParseBody = method !== 'GET';
-
-      expect(shouldParseBody).toBe(true);
-    });
-
-    it('should not parse body for GET requests', () => {
-      const method: string = 'GET';
-      const shouldParseBody = method !== 'GET';
-
-      expect(shouldParseBody).toBe(false);
-    });
-  });
-
-  describe('Session Management', () => {
-    it('should create new transport for stateless mode', () => {
-      expect(mockConfig.stateful).toBe(false);
-
-      const existingTransport = undefined;
-      const shouldCreateNew = !existingTransport;
-
-      expect(shouldCreateNew).toBe(true);
-    });
-
-    it('should reuse transport for stateful mode', () => {
-      const statefulConfig = { ...mockConfig, stateful: true };
-      const existingTransport = {
-        transport: {},
-        server: {},
-      };
-
-      expect(statefulConfig.stateful).toBe(true);
-      expect(existingTransport).toBeDefined();
-      // Should use existingTransport
-    });
-
-    it('should read session ID from header', () => {
-      const headers = {
-        'mcp-session-id': 'session-123',
-      };
-
-      const sessionId = headers['mcp-session-id'];
-
-      expect(sessionId).toBe('session-123');
-    });
-
-    it('should handle missing session ID', () => {
-      const headers = {};
-      const sessionId = headers['mcp-session-id' as keyof typeof headers];
-
-      expect(sessionId).toBeUndefined();
-    });
-  });
-
-  describe('Transport Lifecycle', () => {
-    it('should connect server on first use', () => {
-      const existingTransport = undefined;
-      const isFirstConnection = !existingTransport;
-
-      expect(isFirstConnection).toBe(true);
-      // Should call server.connect(transport)
-    });
-
-    it('should skip connection for existing transport', () => {
-      const existingTransport = {
-        transport: {},
-        server: {},
-      };
-      const isFirstConnection = !existingTransport;
-
-      expect(isFirstConnection).toBe(false);
-      // Should not call server.connect again
-    });
-
-    it('should handle request through transport', () => {
-      const request = { method: 'POST', url: '/mcp' };
-      const response = {};
-      const body = { method: 'tools/call' };
-
-      expect(request.method).toBe('POST');
-      // Should call transport.handleRequest(req, res, body)
-    });
-  });
-
-  describe('Stateful vs Stateless', () => {
-    it('should return transport state in stateful mode', () => {
-      const statefulConfig = { ...mockConfig, stateful: true };
-
-      expect(statefulConfig.stateful).toBe(true);
-      // handleStreamRequest should return state
-    });
-
-    it('should not return state in stateless mode', () => {
-      expect(mockConfig.stateful).toBe(false);
-      // handleStreamRequest should return void
-    });
-
-    it('should store state in sessions map for stateful mode', () => {
-      const sessions = new Map();
-      const sessionId = 'session-123';
-      const state = {
-        transport: {},
-        server: {},
-      };
-
-      sessions.set(sessionId, state);
-
-      expect(sessions.get(sessionId)).toBe(state);
-      expect(sessions.size).toBe(1);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle transport creation errors', () => {
-      const error = new Error('Failed to create transport');
-
-      expect(error.message).toBe('Failed to create transport');
-      // Should propagate error
-    });
-
-    it('should handle request handling errors', () => {
-      const error = new Error('Failed to handle request');
-
-      expect(error.message).toBe('Failed to handle request');
-      // Should propagate error
-    });
-
-    it('should handle server connection errors', () => {
-      const error = new Error('Failed to connect server');
-
-      expect(error.message).toBe('Failed to connect server');
-      // Should propagate error
-    });
-  });
-
-  describe('Transport State Type', () => {
-    it('should have transport and server properties', () => {
-      const state = {
-        transport: { handleRequest: vi.fn() },
-        server: { connect: vi.fn() },
-      };
-
-      expect(state.transport).toBeDefined();
-      expect(state.server).toBeDefined();
-      expect(typeof state.transport.handleRequest).toBe('function');
-      expect(typeof state.server.connect).toBe('function');
-    });
-
-    it('should distinguish from SSE transport state', () => {
-      const streamState = {
-        transport: { handleRequest: vi.fn() },
-        server: {},
-      };
-
-      const sseState = {
-        transport: { sessionId: 'sse-123' },
-        server: {},
-      };
-
-      expect('handleRequest' in streamState.transport).toBe(true);
-      expect('sessionId' in sseState.transport).toBe(true);
-      expect('sessionId' in streamState.transport).toBe(false);
-    });
-  });
-
-  describe('Protocol Differences', () => {
-    it('should not use sessionId in transport like SSE does', () => {
-      const streamTransport = {
-        handleRequest: vi.fn(),
-      };
-
-      expect('sessionId' in streamTransport).toBe(false);
-      // Stream transport doesn't embed sessionId in transport object
-    });
-
-    it('should use HTTP headers for session tracking', () => {
-      const sessionHeader = 'Mcp-Session-Id';
-
-      expect(sessionHeader).toBe('Mcp-Session-Id');
-      // Stream uses headers, not transport properties
-    });
-
-    it('should support both GET and POST unlike SSE', () => {
-      const supportedMethods = ['GET', 'POST'];
-
-      expect(supportedMethods).toContain('GET');
-      expect(supportedMethods).toContain('POST');
-      // SSE uses GET for connection, POST for messages
-      // Stream uses both for the same endpoint
-    });
-  });
-});