@coffeerunhobby/mcp-ha-connect 0.5.0

package/src/wrapper.ts

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+/**
+ * HTTP Wrapper for Home Assistant MCP Server
+ * Provides REST API endpoints that call MCP tools under the hood
+ * Compatible with legacy mcp-wrapper.js behavior
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Use relative path from wrapper location
+const MCP_PATH = path.join(__dirname, 'index.js');
+const PORT = parseInt(process.env.PORT || '3000', 10);
+
+// ====== FAIL EARLY VALIDATION ======
+function validateConfig(): string[] {
+  const errors: string[] = [];
+
+  if (!process.env.HA_URL) errors.push('ERROR: HA_URL environment variable not set');
+  if (!process.env.HA_TOKEN) errors.push('ERROR: HA_TOKEN environment variable not set');
+
+  if (process.env.HA_URL && !process.env.HA_URL.startsWith('http')) {
+    errors.push('ERROR: HA_URL must start with http:// or https://');
+  }
+
+  if (!existsSync(MCP_PATH)) errors.push(`ERROR: MCP script not found at: ${MCP_PATH}`);
+
+  const nodeVersion = process.versions.node.split('.')[0];
+  if (parseInt(nodeVersion) < 18) {
+    errors.push(`ERROR: Node.js 18+ required, found: ${process.versions.node}`);
+  }
+
+  return errors;
+}
+
+const configErrors = validateConfig();
+if (configErrors.length > 0) {
+  console.error('\nConfiguration Errors:\n');
+  configErrors.forEach(err => console.error(err));
+  console.error('\nFix these issues before starting:');
+  console.error('export HA_URL=http://homeassistant.10.0.0.19.nip.io:8123');
+  console.error('export HA_TOKEN=your_long_lived_access_token\n');
+  process.exit(1);
+}
+
+// ====== CORS ======
+const ALLOWED_ORIGINS = new Set([
+  "http://127.0.0.1:8282",
+  "http://localhost:8282"
+]);
+
+function setCors(req: IncomingMessage, res: ServerResponse): void {
+  const origin = req.headers.origin;
+
+  if (origin && ALLOWED_ORIGINS.has(origin)) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+  } else {
+    // LAN/dev friendly. Tighten if you expose this publicly.
+    res.setHeader("Access-Control-Allow-Origin", "*");
+  }
+
+  res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  res.setHeader("Access-Control-Max-Age", "86400");
+}
+
+// ====== HELPERS ======
+interface McpResult {
+  result?: {
+    content?: Array<{ text?: string }>;
+  };
+}
+
+function extractText(result: McpResult): string | undefined {
+  return result?.result?.content?.[0]?.text;
+}
+
+function tryParseJson(text: string | undefined): any {
+  if (typeof text !== 'string') return null;
+  const t = text.trim();
+  if (!t) return null;
+  try {
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+}
+
+function sendJson(res: ServerResponse, statusCode: number, obj: any): void {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(obj));
+}
+
+function readBody(req: IncomingMessage): Promise<any> {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => {
+      if (!body.trim()) return resolve(null);
+      try {
+        resolve(JSON.parse(body));
+      } catch (e) {
+        reject(new Error(`Invalid JSON body: ${(e as Error).message}`));
+      }
+    });
+  });
+}
+
+// This runs the MCP stdio script once per request
+function runMcpWithJsonInput(jsonObj: any): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const mcp = spawn('node', [MCP_PATH], {
+      env: {
+        ...process.env,
+        HA_URL: process.env.HA_URL!,
+        HA_TOKEN: process.env.HA_TOKEN!,
+      },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let mcpOutput = '';
+    let mcpError = '';
+    let headerSeen = false;
+
+    mcp.stdout.on('data', (data) => {
+      const str = data.toString();
+      if (str.includes('Home Assistant MCP server running') || str.includes('MCP server connected and ready')) {
+        headerSeen = true;
+        return;
+      }
+      if (headerSeen) mcpOutput += str;
+    });
+
+    mcp.stderr.on('data', (data) => {
+      const str = data.toString();
+      if (!str.includes('Home Assistant MCP server running') && !str.includes('MCP server connected and ready')) {
+        mcpError += str;
+      } else {
+        headerSeen = true;
+      }
+    });
+
+    mcp.stdin.write(JSON.stringify(jsonObj) + '\n');
+    mcp.stdin.end();
+
+    const timeout = setTimeout(() => {
+      mcp.kill();
+      reject(new Error('MCP timeout after 30s'));
+    }, 30000);
+
+    mcp.on('close', (code) => {
+      clearTimeout(timeout);
+
+      if (!mcpOutput.trim()) {
+        reject(new Error(`No output from MCP (exit=${code}). stderr=${mcpError}`));
+        return;
+      }
+
+      try {
+        const parsed = JSON.parse(mcpOutput.trim());
+        resolve(parsed);
+      } catch (e) {
+        reject(new Error(`Invalid JSON from MCP: ${(e as Error).message}. raw=${mcpOutput}`));
+      }
+    });
+
+    mcp.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+function callMcpTool(name: string, argumentsObj?: any): Promise<any> {
+  const request = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name, arguments: argumentsObj ?? {} }
+  };
+  return runMcpWithJsonInput(request);
+}
+
+// ====== SERVER ======
+const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  setCors(req, res);
+
+  // Preflight
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  // Health
+  if (req.method === 'GET' && req.url === '/health') {
+    sendJson(res, 200, {
+      status: 'ok',
+      mcp_path: MCP_PATH,
+      ha_url: process.env.HA_URL,
+      token_configured: !!process.env.HA_TOKEN,
+    });
+    return;
+  }
+
+  // OpenAPI served from disk
+  if (req.method === 'GET' && (req.url === '/openapi.json' || req.url === '/openapi')) {
+    try {
+      const openApiPath = path.join(__dirname, '..', 'openapi.json');
+      const { readFileSync } = await import('fs');
+      const content = readFileSync(openApiPath, 'utf8');
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(content);
+    } catch (e) {
+      sendJson(res, 500, {
+        error: "Failed to read openapi.json",
+        details: (e as Error).message
+      });
+    }
+    return;
+  }
+
+  // ===== Pretty REST endpoints =====
+  if (req.method === 'POST' && req.url === '/get_all_sensors') {
+    try {
+      const raw = await callMcpTool('getStates', {});
+      const text = extractText(raw);
+      const parsed = tryParseJson(text);
+
+      if (!parsed || !Array.isArray(parsed.entities)) {
+        sendJson(res, 502, { error: "Unexpected MCP response format", raw });
+        return;
+      }
+
+      // Filter to sensors only to match legacy behavior
+      const sensors = parsed.entities.filter((e: any) =>
+        e.entity_id?.startsWith('sensor.')
+      );
+
+      sendJson(res, 200, { count: sensors.length, sensors, raw });
+    } catch (e) {
+      sendJson(res, 500, { error: (e as Error).message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && req.url === '/get_sensor_state') {
+    try {
+      const body = await readBody(req);
+      const entity_id = body?.entity_id;
+      if (!entity_id || typeof entity_id !== 'string') {
+        sendJson(res, 400, { error: "Missing required field: entity_id (string)" });
+        return;
+      }
+
+      const raw = await callMcpTool('getState', { entity_id });
+      const text = extractText(raw);
+      const entity = tryParseJson(text);
+
+      if (!entity || typeof entity !== 'object') {
+        sendJson(res, 502, { error: "Unexpected MCP response format", raw });
+        return;
+      }
+
+      sendJson(res, 200, { entity, raw });
+    } catch (e) {
+      sendJson(res, 500, { error: (e as Error).message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && req.url === '/control_device') {
+    try {
+      const body = await readBody(req);
+      const domain = body?.domain;
+      const service = body?.service;
+      const data = body?.data ?? {};
+
+      if (!domain || typeof domain !== 'string') {
+        sendJson(res, 400, { error: "Missing required field: domain (string)" });
+        return;
+      }
+      if (!service || typeof service !== 'string') {
+        sendJson(res, 400, { error: "Missing required field: service (string)" });
+        return;
+      }
+      if (typeof data !== 'object' || Array.isArray(data) || data === null) {
+        sendJson(res, 400, { error: "Field 'data' must be an object" });
+        return;
+      }
+
+      const raw = await callMcpTool('callService', {
+        domain,
+        service,
+        service_data: data,
+      });
+      const text = extractText(raw);
+      const parsed = tryParseJson(text);
+
+      sendJson(res, 200, { ok: true, result: parsed ?? text ?? null, raw });
+    } catch (e) {
+      sendJson(res, 500, { error: (e as Error).message });
+    }
+    return;
+  }
+
+  // ===== Raw passthrough endpoint (for n8n compatibility) =====
+  if (req.method === 'POST' && req.url === '/') {
+    try {
+      const body = await readBody(req);
+      if (!body) {
+        sendJson(res, 400, { error: "Empty JSON body" });
+        return;
+      }
+      const result = await runMcpWithJsonInput(body);
+      sendJson(res, 200, result);
+    } catch (e) {
+      sendJson(res, 500, { error: (e as Error).message });
+    }
+    return;
+  }
+
+  sendJson(res, 404, { error: 'Not found' });
+});
+
+server.listen(PORT, '0.0.0.0', () => {
+  console.log('MCP Wrapper started successfully!');
+  console.log(`Listening on 0.0.0.0:${PORT}`);
+  console.log(`MCP script: ${MCP_PATH}`);
+  console.log(`Home Assistant: ${process.env.HA_URL}`);
+  console.log(`Token: ${process.env.HA_TOKEN ? '***configured***' : 'MISSING'}`);
+  console.log(`\nTest with: curl http://localhost:${PORT}/health\n`);
+});

package/tests/config.test.ts

@@ -0,0 +1,332 @@
+/**
+ * Configuration tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { loadConfig, validateConfig } from '../src/config.js';
+import type { EnvironmentConfig } from '../src/config.js';
+
+describe('loadConfig', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+  });
+
+  it('should load valid configuration from environment', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      HA_STRICT_SSL: 'false',
+      HA_TIMEOUT: '30000',
+      MCP_SERVER_LOG_LEVEL: 'info',
+      MCP_SERVER_LOG_FORMAT: 'plain',
+      MCP_SERVER_USE_HTTP: 'false',
+      MCP_SERVER_STATEFUL: 'false',
+    };
+
+    const config = loadConfig(env);
+
+    expect(config.baseUrl).toBe('http://homeassistant.10.0.0.19.nip.io:8123');
+    expect(config.token).toBe('test-token-12345');
+    expect(config.strictSsl).toBe(false);
+    expect(config.timeout).toBe(30000);
+    expect(config.logLevel).toBe('info');
+    expect(config.logFormat).toBe('plain');
+    expect(config.useHttp).toBe(false);
+    expect(config.stateful).toBe(false);
+  });
+
+  it('should apply default values for optional fields', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+    };
+
+    const config = loadConfig(env);
+
+    expect(config.strictSsl).toBe(true); // default
+    expect(config.timeout).toBe(30000); // default
+    expect(config.logLevel).toBe('info'); // default
+    expect(config.logFormat).toBe('plain'); // default
+    expect(config.useHttp).toBe(false); // default
+    expect(config.stateful).toBe(false); // default
+    expect(config.httpEnableHealthcheck).toBe(true); // default
+    expect(config.httpAllowCors).toBe(true); // default
+    expect(config.httpTransport).toBe('stream'); // default
+  });
+
+  it('should remove trailing slash from baseUrl', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123/',
+      HA_TOKEN: 'test-token-12345',
+    };
+
+    const config = loadConfig(env);
+
+    expect(config.baseUrl).toBe('http://homeassistant.10.0.0.19.nip.io:8123');
+  });
+
+  it('should throw error for missing HA_URL', () => {
+    const env = {
+      HA_TOKEN: 'test-token-12345',
+    };
+
+    expect(() => loadConfig(env)).toThrow('Invalid environment configuration');
+  });
+
+  it('should throw error for missing HA_TOKEN', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+    };
+
+    expect(() => loadConfig(env)).toThrow('Invalid environment configuration');
+  });
+
+  it('should throw error for invalid HA_URL', () => {
+    const env = {
+      HA_URL: 'not-a-url',
+      HA_TOKEN: 'test-token-12345',
+    };
+
+    expect(() => loadConfig(env)).toThrow('Invalid environment configuration');
+  });
+
+  it('should parse HTTP configuration when USE_HTTP is true', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_SERVER_USE_HTTP: 'true',
+      MCP_HTTP_PORT: '3000',
+      MCP_HTTP_TRANSPORT: 'stream',
+      MCP_HTTP_BIND_ADDR: '127.0.0.1',
+      MCP_HTTP_PATH: '/mcp',
+      MCP_HTTP_ENABLE_HEALTHCHECK: 'true',
+      MCP_HTTP_HEALTHCHECK_PATH: '/health',
+      MCP_HTTP_ALLOW_CORS: 'true',
+      MCP_HTTP_ALLOWED_ORIGINS: '127.0.0.1,localhost',
+    };
+
+    const config = loadConfig(env);
+
+    expect(config.useHttp).toBe(true);
+    expect(config.httpPort).toBe(3000);
+    expect(config.httpTransport).toBe('stream');
+    expect(config.httpBindAddr).toBe('127.0.0.1');
+    expect(config.httpPath).toBe('/mcp');
+    expect(config.httpEnableHealthcheck).toBe(true);
+    expect(config.httpHealthcheckPath).toBe('/health');
+    expect(config.httpAllowCors).toBe(true);
+    expect(config.httpAllowedOrigins).toEqual(['127.0.0.1', 'localhost']);
+  });
+
+  it('should use default httpPath based on transport', () => {
+    const envStream = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_TRANSPORT: 'stream',
+    };
+
+    const configStream = loadConfig(envStream);
+    expect(configStream.httpPath).toBe('/mcp');
+
+    const envSse = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_TRANSPORT: 'sse',
+    };
+
+    const configSse = loadConfig(envSse);
+    expect(configSse.httpPath).toBe('/sse');
+  });
+
+  it('should handle wildcard in allowed origins', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_ALLOWED_ORIGINS: '*',
+    };
+
+    const config = loadConfig(env);
+
+    // Wildcard should result in empty array to disable SDK validation
+    expect(config.httpAllowedOrigins).toEqual([]);
+  });
+
+  it('should parse comma-separated origins', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_ALLOWED_ORIGINS: 'http://mcpserver.10.0.0.18.nip.io:3000,http://192.168.0.10:8080,localhost',
+    };
+
+    const config = loadConfig(env);
+
+    expect(config.httpAllowedOrigins).toEqual([
+      'http://mcpserver.10.0.0.18.nip.io:3000',
+      'http://192.168.0.10:8080',
+      'localhost',
+    ]);
+  });
+
+  it('should throw error for invalid bind address', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_BIND_ADDR: 'invalid-ip',
+    };
+
+    expect(() => loadConfig(env)).toThrow('MCP_HTTP_BIND_ADDR must be a valid IPv4 or IPv6 address');
+  });
+
+  it('should accept valid IPv4 bind address', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_BIND_ADDR: '192.168.1.100',
+    };
+
+    const config = loadConfig(env);
+    expect(config.httpBindAddr).toBe('192.168.1.100');
+  });
+
+  it('should accept valid IPv6 bind address', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      MCP_HTTP_BIND_ADDR: '::1',
+    };
+
+    const config = loadConfig(env);
+    expect(config.httpBindAddr).toBe('::1');
+  });
+
+  it('should parse numeric timeout', () => {
+    const env = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      HA_TIMEOUT: '45000',
+    };
+
+    const config = loadConfig(env);
+    expect(config.timeout).toBe(45000);
+  });
+
+  it('should support all log levels', () => {
+    const levels = ['debug', 'info', 'warn', 'error'] as const;
+
+    for (const level of levels) {
+      const env = {
+        HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        HA_TOKEN: 'test-token-12345',
+        MCP_SERVER_LOG_LEVEL: level,
+      };
+
+      const config = loadConfig(env);
+      expect(config.logLevel).toBe(level);
+    }
+  });
+
+  it('should support all log formats', () => {
+    const formats = ['plain', 'json', 'gcp-json'] as const;
+
+    for (const format of formats) {
+      const env = {
+        HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        HA_TOKEN: 'test-token-12345',
+        MCP_SERVER_LOG_FORMAT: format,
+      };
+
+      const config = loadConfig(env);
+      expect(config.logFormat).toBe(format);
+    }
+  });
+
+  it('should support both HTTP transports', () => {
+    const transports = ['stream', 'sse'] as const;
+
+    for (const transport of transports) {
+      const env = {
+        HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        HA_TOKEN: 'test-token-12345',
+        MCP_HTTP_TRANSPORT: transport,
+      };
+
+      const config = loadConfig(env);
+      expect(config.httpTransport).toBe(transport);
+    }
+  });
+
+  it('should parse boolean strings correctly', () => {
+    const envTrue = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      HA_STRICT_SSL: 'true',
+      MCP_SERVER_USE_HTTP: 'true',
+      MCP_SERVER_STATEFUL: 'true',
+    };
+
+    const configTrue = loadConfig(envTrue);
+    expect(configTrue.strictSsl).toBe(true);
+    expect(configTrue.useHttp).toBe(true);
+    expect(configTrue.stateful).toBe(true);
+
+    const envFalse = {
+      HA_URL: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      HA_TOKEN: 'test-token-12345',
+      HA_STRICT_SSL: 'false',
+      MCP_SERVER_USE_HTTP: 'false',
+      MCP_SERVER_STATEFUL: 'false',
+    };
+
+    const configFalse = loadConfig(envFalse);
+    expect(configFalse.strictSsl).toBe(false);
+    expect(configFalse.useHttp).toBe(false);
+    expect(configFalse.stateful).toBe(false);
+  });
+});
+
+describe('validateConfig', () => {
+  it('should validate valid configuration', () => {
+    const config: EnvironmentConfig = {
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      token: 'test-token-12345',
+      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,
+      sseEventsEnabled: true,
+      sseEventsPath: '/subscribe_events',
+      rateLimitEnabled: true,
+      rateLimitWindowMs: 60000,
+      rateLimitMaxRequests: 100,
+    };
+
+    expect(() => validateConfig(config)).not.toThrow();
+  });
+
+  it('should throw error for missing baseUrl', () => {
+    const config = {
+      token: 'test-token-12345',
+    } as EnvironmentConfig;
+
+    expect(() => validateConfig(config)).toThrow('Invalid configuration');
+  });
+
+  it('should throw error for missing token', () => {
+    const config = {
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+    } as EnvironmentConfig;
+
+    expect(() => validateConfig(config)).toThrow('Invalid configuration');
+  });
+});