@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/utils/config-validations.test.ts

@@ -1,352 +0,0 @@
-/**
- * Configuration validation utilities tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { isValidBindAddress, isValidHostname, isValidOrigin } from '../../src/utils/config-validations.js';
-
-describe('isValidBindAddress', () => {
-  describe('Valid IPv4 addresses', () => {
-    it('should accept localhost 127.0.0.1', () => {
-      expect(isValidBindAddress('127.0.0.1')).toBe(true);
-    });
-
-    it('should accept 0.0.0.0 (all interfaces)', () => {
-      expect(isValidBindAddress('0.0.0.0')).toBe(true);
-    });
-
-    it('should accept private IP 192.168.1.1', () => {
-      expect(isValidBindAddress('192.168.1.1')).toBe(true);
-    });
-
-    it('should accept private IP 10.0.0.1', () => {
-      expect(isValidBindAddress('10.0.0.1')).toBe(true);
-    });
-
-    it('should accept private IP 172.16.0.1', () => {
-      expect(isValidBindAddress('172.16.0.1')).toBe(true);
-    });
-
-    it('should accept maximum octet values 255.255.255.255', () => {
-      expect(isValidBindAddress('255.255.255.255')).toBe(true);
-    });
-
-    it('should accept public IP 8.8.8.8', () => {
-      expect(isValidBindAddress('8.8.8.8')).toBe(true);
-    });
-  });
-
-  describe('Invalid IPv4 addresses', () => {
-    it('should reject octet > 255', () => {
-      expect(isValidBindAddress('256.0.0.1')).toBe(false);
-      expect(isValidBindAddress('192.168.256.1')).toBe(false);
-    });
-
-    it('should reject negative octets', () => {
-      expect(isValidBindAddress('-1.0.0.1')).toBe(false);
-    });
-
-    it('should reject too few octets', () => {
-      expect(isValidBindAddress('192.168.1')).toBe(false);
-    });
-
-    it('should reject too many octets', () => {
-      expect(isValidBindAddress('192.168.1.1.1')).toBe(false);
-    });
-
-    it('should reject non-numeric octets', () => {
-      expect(isValidBindAddress('abc.def.ghi.jkl')).toBe(false);
-    });
-
-    it('should reject empty string', () => {
-      expect(isValidBindAddress('')).toBe(false);
-    });
-
-    it('should reject hostnames', () => {
-      expect(isValidBindAddress('localhost')).toBe(false);
-    });
-  });
-
-  describe('Valid IPv6 addresses', () => {
-    it('should accept localhost ::1', () => {
-      expect(isValidBindAddress('::1')).toBe(true);
-    });
-
-    it('should accept all interfaces ::', () => {
-      expect(isValidBindAddress('::')).toBe(true);
-    });
-
-    it('should accept full IPv6 address', () => {
-      expect(isValidBindAddress('2001:0db8:85a3:0000:0000:8a2e:0370:7334')).toBe(true);
-    });
-
-    it('should accept compressed IPv6 address', () => {
-      expect(isValidBindAddress('2001:db8::1')).toBe(true);
-    });
-
-    it('should accept link-local address', () => {
-      expect(isValidBindAddress('fe80::1')).toBe(true);
-    });
-  });
-
-  describe('Invalid IPv6 addresses', () => {
-    it('should reject malformed IPv6', () => {
-      expect(isValidBindAddress('gggg::1')).toBe(false);
-    });
-
-    it('should reject invalid IPv6 with extra colons', () => {
-      // Node's net.isIPv6 correctly rejects malformed addresses
-      expect(isValidBindAddress(':::1')).toBe(false);
-    });
-
-    it('should reject IPv6 with too many groups', () => {
-      expect(isValidBindAddress('2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234')).toBe(false);
-    });
-  });
-});
-
-describe('isValidHostname', () => {
-  describe('Valid hostnames', () => {
-    it('should accept localhost', () => {
-      expect(isValidHostname('localhost')).toBe(true);
-    });
-
-    it('should accept simple domain', () => {
-      expect(isValidHostname('example.com')).toBe(true);
-    });
-
-    it('should accept subdomain', () => {
-      expect(isValidHostname('api.example.com')).toBe(true);
-    });
-
-    it('should accept hyphenated domain', () => {
-      expect(isValidHostname('my-app.example.com')).toBe(true);
-    });
-
-    it('should accept single character labels', () => {
-      expect(isValidHostname('a.b.c')).toBe(true);
-    });
-
-    it('should accept numeric labels', () => {
-      expect(isValidHostname('123.example.com')).toBe(true);
-    });
-  });
-
-  describe('Invalid hostnames', () => {
-    it('should reject empty string', () => {
-      expect(isValidHostname('')).toBe(false);
-    });
-
-    it('should reject hostname starting with hyphen', () => {
-      expect(isValidHostname('-example.com')).toBe(false);
-    });
-
-    it('should reject hostname ending with hyphen', () => {
-      expect(isValidHostname('example-.com')).toBe(false);
-    });
-
-    it('should reject hostname with consecutive dots', () => {
-      expect(isValidHostname('example..com')).toBe(false);
-    });
-
-    it('should reject hostname with special characters', () => {
-      expect(isValidHostname('example@com')).toBe(false);
-      expect(isValidHostname('example_com')).toBe(false);
-    });
-
-    it('should reject hostname exceeding 253 characters', () => {
-      const longHostname = 'a'.repeat(254);
-      expect(isValidHostname(longHostname)).toBe(false);
-    });
-
-    it('should reject label exceeding 63 characters', () => {
-      const longLabel = 'a'.repeat(64) + '.com';
-      expect(isValidHostname(longLabel)).toBe(false);
-    });
-  });
-});
-
-describe('isValidOrigin', () => {
-  describe('Valid origins', () => {
-    it('should accept wildcard *', () => {
-      expect(isValidOrigin('*')).toBe(true);
-    });
-
-    it('should accept localhost', () => {
-      expect(isValidOrigin('localhost')).toBe(true);
-    });
-
-    it('should accept 127.0.0.1', () => {
-      expect(isValidOrigin('127.0.0.1')).toBe(true);
-    });
-
-    it('should accept ::1', () => {
-      expect(isValidOrigin('::1')).toBe(true);
-    });
-
-    it('should accept full URL with http', () => {
-      expect(isValidOrigin('http://localhost:3000')).toBe(true);
-    });
-
-    it('should accept full URL with https', () => {
-      expect(isValidOrigin('https://example.com')).toBe(true);
-    });
-
-    it('should accept URL with port', () => {
-      expect(isValidOrigin('http://192.168.0.10:8080')).toBe(true);
-    });
-
-    it('should accept simple hostname', () => {
-      expect(isValidOrigin('example.com')).toBe(true);
-    });
-
-    it('should accept hostname with subdomain', () => {
-      expect(isValidOrigin('api.example.com')).toBe(true);
-    });
-
-    it('should accept hostname with hyphen', () => {
-      expect(isValidOrigin('my-app.example.com')).toBe(true);
-    });
-
-    it('should accept IP address as origin', () => {
-      expect(isValidOrigin('192.168.1.100')).toBe(true);
-    });
-  });
-
-  describe('Invalid origins', () => {
-    it('should reject empty string', () => {
-      expect(isValidOrigin('')).toBe(false);
-    });
-
-    it('should reject spaces', () => {
-      expect(isValidOrigin('  ')).toBe(false);
-    });
-
-    it('should reject special characters not allowed in hostnames', () => {
-      expect(isValidOrigin('invalid@origin')).toBe(false);
-    });
-
-    it('should reject invalid URL protocol', () => {
-      expect(isValidOrigin('ftp://example.com')).toBe(true); // URL is valid even if protocol is unusual
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('should handle URL with path', () => {
-      expect(isValidOrigin('http://example.com/path')).toBe(true);
-    });
-
-    it('should handle URL with query string', () => {
-      expect(isValidOrigin('http://example.com?query=value')).toBe(true);
-    });
-
-    it('should handle URL with hash', () => {
-      expect(isValidOrigin('http://example.com#hash')).toBe(true);
-    });
-
-    it('should handle mixed case', () => {
-      expect(isValidOrigin('HTTP://EXAMPLE.COM')).toBe(true);
-    });
-
-    it('should handle IPv6 in URL', () => {
-      expect(isValidOrigin('http://[::1]:8080')).toBe(true);
-    });
-  });
-
-  describe('Common use cases', () => {
-    it('should accept development origins', () => {
-      const devOrigins = [
-        'http://mcpserver.10.0.0.18.nip.io:3000',
-        'http://localhost:8080',
-        'http://127.0.0.1:8080',
-        'localhost',
-      ];
-
-      for (const origin of devOrigins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-
-    it('should accept production origins', () => {
-      const prodOrigins = [
-        'https://example.com',
-        'https://www.example.com',
-        'https://app.example.com',
-      ];
-
-      for (const origin of prodOrigins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-
-    it('should accept local network origins', () => {
-      const localOrigins = [
-        'http://192.168.0.10:8080',
-        'http://10.0.0.5:3000',
-        '192.168.1.100',
-      ];
-
-      for (const origin of localOrigins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-  });
-
-  describe('Security considerations', () => {
-    it('should allow restricting to specific domains', () => {
-      const allowedOrigins = [
-        'https://app.example.com',
-        'https://admin.example.com',
-      ];
-
-      const testOrigin = 'https://app.example.com';
-      expect(isValidOrigin(testOrigin)).toBe(true);
-      expect(allowedOrigins).toContain(testOrigin);
-    });
-
-    it('should support localhost-only configuration', () => {
-      const localhostOrigins = [
-        'localhost',
-        '127.0.0.1',
-        '::1',
-      ];
-
-      for (const origin of localhostOrigins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-
-    it('should support wildcard for development', () => {
-      const allowAll = '*';
-      expect(isValidOrigin(allowAll)).toBe(true);
-    });
-  });
-
-  describe('Integration with config', () => {
-    it('should validate comma-separated origins', () => {
-      const originsString = 'http://mcpserver.10.0.0.18.nip.io:3000,http://192.168.0.10:8080,localhost';
-      const origins = originsString.split(',').map(s => s.trim());
-
-      for (const origin of origins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-
-    it('should detect invalid origin in list', () => {
-      const originsString = 'http://mcpserver.10.0.0.18.nip.io:3000,invalid@origin,localhost';
-      const origins = originsString.split(',').map(s => s.trim());
-
-      const invalidOrigin = origins.find(origin => !isValidOrigin(origin));
-      expect(invalidOrigin).toBe('invalid@origin');
-    });
-
-    it('should handle whitespace in origin list', () => {
-      const originsString = ' http://mcpserver.10.0.0.18.nip.io:3000 , localhost ';
-      const origins = originsString.split(',').map(s => s.trim()).filter(Boolean);
-
-      for (const origin of origins) {
-        expect(isValidOrigin(origin)).toBe(true);
-      }
-    });
-  });
-});

package/tests/utils/jwt.test.ts

@@ -1,115 +0,0 @@
-/**
- * JWT utility tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { createJwt, verifyJwt } from '../../src/utils/jwt.js';
-
-const SECRET = 'test-secret-key-32chars-minimum!';
-
-describe('JWT', () => {
-  describe('createJwt', () => {
-    it('should create valid JWT with payload', () => {
-      const token = createJwt({ sub: 'user1', role: 'admin' }, SECRET);
-
-      expect(token).toMatch(/^[\w-]+\.[\w-]+\.[\w-]+$/);
-      const parts = token.split('.');
-      expect(parts).toHaveLength(3);
-    });
-
-    it('should create JWT that can be verified', () => {
-      const payload = { sub: 'user1', custom: 'data' };
-      const token = createJwt(payload, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-      expect(result.payload?.sub).toBe('user1');
-      expect(result.payload?.custom).toBe('data');
-    });
-  });
-
-  describe('verifyJwt', () => {
-    it('should verify valid token', () => {
-      const token = createJwt({ sub: 'test' }, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-      expect(result.payload?.sub).toBe('test');
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should reject token with wrong secret', () => {
-      const token = createJwt({ sub: 'test' }, SECRET);
-      const result = verifyJwt(token, 'wrong-secret');
-
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('bad signature');
-    });
-
-    it('should reject malformed token', () => {
-      expect(verifyJwt('not.a.valid.token', SECRET)).toEqual({
-        valid: false,
-        error: 'bad format',
-      });
-
-      expect(verifyJwt('onlyonepart', SECRET)).toEqual({
-        valid: false,
-        error: 'bad format',
-      });
-
-      expect(verifyJwt('two.parts', SECRET)).toEqual({
-        valid: false,
-        error: 'bad format',
-      });
-    });
-
-    it('should reject expired token', () => {
-      const expiredPayload = { sub: 'test', exp: Math.floor(Date.now() / 1000) - 100 };
-      const token = createJwt(expiredPayload, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('expired');
-    });
-
-    it('should accept token without exp', () => {
-      const token = createJwt({ sub: 'service' }, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-    });
-
-    it('should accept token with future exp', () => {
-      const futurePayload = { sub: 'test', exp: Math.floor(Date.now() / 1000) + 3600 };
-      const token = createJwt(futurePayload, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-    });
-
-    it('should handle token with iat claim', () => {
-      const payload = { sub: 'test', iat: Math.floor(Date.now() / 1000) };
-      const token = createJwt(payload, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-      expect(result.payload?.iat).toBeDefined();
-    });
-
-    it('should preserve all custom claims', () => {
-      const payload = {
-        sub: 'user1',
-        role: 'admin',
-        permissions: ['read', 'write'],
-        metadata: { key: 'value' },
-      };
-      const token = createJwt(payload, SECRET);
-      const result = verifyJwt(token, SECRET);
-
-      expect(result.valid).toBe(true);
-      expect(result.payload?.role).toBe('admin');
-      expect(result.payload?.permissions).toEqual(['read', 'write']);
-      expect(result.payload?.metadata).toEqual({ key: 'value' });
-    });
-  });
-});