@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/utils/logger.test.ts

@@ -1,327 +0,0 @@
-/**
- * Logger tests
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { initLogger, setLevel, logger } from '../../src/utils/logger.js';
-import type { LogLevel, LogFormat } from '../../src/utils/logger.js';
-
-describe('Logger', () => {
-  beforeEach(() => {
-    // Reset to default configuration
-    initLogger('info', 'plain', false);
-  });
-
-  describe('initLogger', () => {
-    it('should initialize with default level and format', () => {
-      initLogger('info', 'plain', false);
-
-      // Logger should be initialized without errors
-      expect(logger).toBeDefined();
-      expect(logger.info).toBeDefined();
-      expect(logger.debug).toBeDefined();
-      expect(logger.warn).toBeDefined();
-      expect(logger.error).toBeDefined();
-    });
-
-    it('should support all log levels', () => {
-      const levels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'silent'];
-
-      for (const level of levels) {
-        expect(() => initLogger(level, 'plain', false)).not.toThrow();
-      }
-    });
-
-    it('should support all log formats', () => {
-      const formats: LogFormat[] = ['plain', 'json', 'gcp-json'];
-
-      for (const format of formats) {
-        expect(() => initLogger('info', format, false)).not.toThrow();
-      }
-    });
-
-    it('should configure stderr output when useStderr is true', () => {
-      expect(() => initLogger('info', 'plain', true)).not.toThrow();
-
-      // Logger should be configured to use stderr
-    });
-
-    it('should configure stdout output when useStderr is false', () => {
-      expect(() => initLogger('info', 'plain', false)).not.toThrow();
-
-      // Logger should be configured to use stdout
-    });
-  });
-
-  describe('setLevel', () => {
-    it('should change log level dynamically', () => {
-      initLogger('info', 'plain', false);
-
-      expect(() => setLevel('debug')).not.toThrow();
-      expect(() => setLevel('warn')).not.toThrow();
-      expect(() => setLevel('error')).not.toThrow();
-    });
-
-    it('should accept all valid log levels', () => {
-      const levels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'silent'];
-
-      for (const level of levels) {
-        expect(() => setLevel(level)).not.toThrow();
-      }
-    });
-  });
-
-  describe('Log methods', () => {
-    it('should have debug method', () => {
-      expect(typeof logger.debug).toBe('function');
-      expect(() => logger.debug('Test debug message')).not.toThrow();
-    });
-
-    it('should have info method', () => {
-      expect(typeof logger.info).toBe('function');
-      expect(() => logger.info('Test info message')).not.toThrow();
-    });
-
-    it('should have warn method', () => {
-      expect(typeof logger.warn).toBe('function');
-      expect(() => logger.warn('Test warn message')).not.toThrow();
-    });
-
-    it('should have error method', () => {
-      expect(typeof logger.error).toBe('function');
-      expect(() => logger.error('Test error message')).not.toThrow();
-    });
-  });
-
-  describe('Log with metadata', () => {
-    it('should log with metadata object', () => {
-      const metadata = {
-        userId: 'user-123',
-        requestId: 'req-456',
-        duration: 123,
-      };
-
-      expect(() => logger.info('Test message', metadata)).not.toThrow();
-    });
-
-    it('should handle Error objects in metadata', () => {
-      const error = new Error('Test error');
-      const metadata = {
-        error,
-        context: 'test',
-      };
-
-      expect(() => logger.error('Error occurred', metadata)).not.toThrow();
-    });
-
-    it('should handle nested objects in metadata', () => {
-      const metadata = {
-        config: {
-          baseUrl: 'http://example.com',
-          timeout: 30000,
-        },
-        user: {
-          id: 'user-123',
-          name: 'Test User',
-        },
-      };
-
-      expect(() => logger.info('Complex metadata', metadata)).not.toThrow();
-    });
-
-    it('should handle arrays in metadata', () => {
-      const metadata = {
-        entities: ['light.living_room', 'sensor.temperature'],
-        tags: ['home', 'automation'],
-      };
-
-      expect(() => logger.info('Array metadata', metadata)).not.toThrow();
-    });
-
-    it('should handle empty metadata', () => {
-      expect(() => logger.info('No metadata')).not.toThrow();
-      expect(() => logger.info('Empty metadata', {})).not.toThrow();
-    });
-  });
-
-  describe('Log formats', () => {
-    it('should format plain logs with uppercase level', () => {
-      initLogger('info', 'plain', false);
-
-      // Plain format should use { level: 'INFO' }
-      expect(() => logger.info('Plain format test')).not.toThrow();
-    });
-
-    it('should format JSON logs with standard structure', () => {
-      initLogger('info', 'json', false);
-
-      // JSON format should use standard pino JSON
-      expect(() => logger.info('JSON format test')).not.toThrow();
-    });
-
-    it('should format GCP JSON logs with severity field', () => {
-      initLogger('info', 'gcp-json', false);
-
-      // GCP format should use { severity: 'INFO' }
-      expect(() => logger.info('GCP format test')).not.toThrow();
-    });
-  });
-
-  describe('Severity mapping for GCP format', () => {
-    it('should map debug to DEBUG', () => {
-      const levelToSeverity = {
-        debug: 'DEBUG',
-        info: 'INFO',
-        warn: 'WARNING',
-        error: 'ERROR',
-      };
-
-      expect(levelToSeverity.debug).toBe('DEBUG');
-    });
-
-    it('should map info to INFO', () => {
-      const levelToSeverity = {
-        debug: 'DEBUG',
-        info: 'INFO',
-        warn: 'WARNING',
-        error: 'ERROR',
-      };
-
-      expect(levelToSeverity.info).toBe('INFO');
-    });
-
-    it('should map warn to WARNING', () => {
-      const levelToSeverity = {
-        debug: 'DEBUG',
-        info: 'INFO',
-        warn: 'WARNING',
-        error: 'ERROR',
-      };
-
-      expect(levelToSeverity.warn).toBe('WARNING');
-    });
-
-    it('should map error to ERROR', () => {
-      const levelToSeverity = {
-        debug: 'DEBUG',
-        info: 'INFO',
-        warn: 'WARNING',
-        error: 'ERROR',
-      };
-
-      expect(levelToSeverity.error).toBe('ERROR');
-    });
-  });
-
-  describe('Error metadata normalization', () => {
-    it('should normalize Error to object with message and stack', () => {
-      const error = new Error('Test error');
-      const normalized = {
-        message: error.message,
-        stack: error.stack,
-      };
-
-      expect(normalized.message).toBe('Test error');
-      expect(normalized.stack).toBeDefined();
-    });
-
-    it('should preserve non-Error values', () => {
-      const metadata = {
-        string: 'test',
-        number: 123,
-        boolean: true,
-        null: null,
-        array: [1, 2, 3],
-        object: { key: 'value' },
-      };
-
-      expect(metadata.string).toBe('test');
-      expect(metadata.number).toBe(123);
-      expect(metadata.boolean).toBe(true);
-      expect(metadata.null).toBeNull();
-      expect(metadata.array).toEqual([1, 2, 3]);
-      expect(metadata.object).toEqual({ key: 'value' });
-    });
-  });
-
-  describe('Timestamp format', () => {
-    it('should use ISO time format', () => {
-      // Pino stdTimeFunctions.isoTime produces ISO 8601 timestamps
-      const now = new Date();
-      const isoTime = now.toISOString();
-
-      expect(isoTime).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-    });
-  });
-
-  describe('Message key', () => {
-    it('should use "message" as the message key', () => {
-      const logEntry = {
-        level: 'INFO',
-        time: '2026-01-08T12:00:00.000Z',
-        message: 'Test message',
-      };
-
-      expect(logEntry.message).toBe('Test message');
-      expect('message' in logEntry).toBe(true);
-    });
-  });
-
-  describe('Base fields', () => {
-    it('should not include base fields like hostname and pid', () => {
-      // baseConfig.base = undefined disables these fields
-      const logEntry = {
-        level: 'INFO',
-        time: '2026-01-08T12:00:00.000Z',
-        message: 'Test message',
-      };
-
-      expect('hostname' in logEntry).toBe(false);
-      expect('pid' in logEntry).toBe(false);
-      expect('name' in logEntry).toBe(false);
-    });
-  });
-
-  describe('Stdio mode behavior', () => {
-    it('should log to stderr in stdio mode to avoid MCP protocol interference', () => {
-      const useStderr = true;
-
-      initLogger('info', 'plain', useStderr);
-
-      // Logger should be configured for stderr
-      expect(() => logger.info('Stdio mode test')).not.toThrow();
-    });
-
-    it('should log to stdout in HTTP mode', () => {
-      const useStderr = false;
-
-      initLogger('info', 'plain', useStderr);
-
-      // Logger should be configured for stdout
-      expect(() => logger.info('HTTP mode test')).not.toThrow();
-    });
-  });
-
-  describe('Environment variable initialization', () => {
-    it('should use MCP_SERVER_LOG_LEVEL from environment by default', () => {
-      // The default instance reads from process.env.MCP_SERVER_LOG_LEVEL
-      const defaultLevel = (process.env.MCP_SERVER_LOG_LEVEL as LogLevel | undefined) ?? 'info';
-
-      expect(['debug', 'info', 'warn', 'error', 'silent']).toContain(defaultLevel);
-    });
-  });
-
-  describe('Multiple logger instances', () => {
-    it('should replace previous instance when reinitializing', () => {
-      initLogger('info', 'plain', false);
-      const firstInit = { ...logger };
-
-      initLogger('debug', 'json', true);
-      const secondInit = { ...logger };
-
-      // Second initialization should replace the first
-      expect(firstInit).toBeDefined();
-      expect(secondInit).toBeDefined();
-    });
-  });
-});

package/tests/utils/redact.test.ts

@@ -1,105 +0,0 @@
-/**
- * Secrets returned by Home Assistant / Omada never reach a tool response.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import type { McpServer } from '@modelcontextprotocol/server';
-
-import { redactSecrets, REDACTED } from '../../src/utils/redact.js';
-import { toToolResult } from '../../src/tools/common.js';
-import { registerOmadaGraphTools } from '../../src/tools/omada/graph.js';
-import type { OmadaClient } from '../../src/omadaClient/index.js';
-
-/** Shape of an Omada SSID detail (GET .../wlans/{wlanId}/ssids/{ssidId}). */
-const ssidDetail = {
-    ssidId: 'node-s55',
-    name: 'node-s55',
-    security: 3,
-    hidePwd: true,
-    pskSetting: { versionPsk: 2, encryptionPsk: 3, gikRekeyPskEnable: false, securityKey: 'HouseWifiPassw0rd!' },
-    macFilterEnable: false,
-};
-
-describe('redactSecrets', () => {
-    it('redacts the Wi-Fi password but keeps flags and numbers with similar names', () => {
-        const out = redactSecrets(ssidDetail);
-
-        expect(out.pskSetting.securityKey).toBe(REDACTED);
-        expect(out.pskSetting.versionPsk).toBe(2);
-        expect(out.pskSetting.encryptionPsk).toBe(3);
-        expect(out.hidePwd).toBe(true);
-        expect(out.name).toBe('node-s55');
-        expect(JSON.stringify(out)).not.toContain('HouseWifiPassw0rd!');
-    });
-
-    it.each([
-        ['RADIUS profile', { authServer: [{ ip: '192.168.0.2', port: 1812, secret: 'radius-s3cret' }], accountingServerPwd: 'acct-pw', coaPassword: 'coa-pw', radiusPwd: 'rp' }],
-        ['PPSK profile', { name: 'kids', ppsk: [{ name: 'tablet', password: 'ppsk-key-1', vlanId: 20 }] }],
-        ['VPN', { preSharedKey: 'ipsec-psk', presharedKey: 'wg-psk', privateKey: 'wg-private', publicKey: 'wg-public' }],
-        ['SNMP', { snmpV1V2CEnable: true, communityString: 'snmp-community' }],
-        ['portal and hotspot', { password: 'portal-pw', authCode: 'auth-code-123', simpleKey: 'sk', md5Key: 'mk' }],
-        ['SSID variants', { psk: 'override-psk', ssidPassword: 'ssid-pw', bridgeSsidPassword: 'bridge-pw', overrideSsidPassword: 'ov-pw' }],
-        ['VRRP and certificates', { key: 'vrrp-key', keyPassword: 'ks-pw', trustPassword: 'trust-pw' }],
-        ['webhooks and tokens', { shardedSecret: 'hook-secret', authToken: 'twilio-token', accessToken: 'at', token: 'user-token' }],
-    ])('redacts every secret in a %s', (_name, input) => {
-        const text = JSON.stringify(redactSecrets(input));
-
-        for (const secret of ['radius-s3cret', 'acct-pw', 'coa-pw', 'ppsk-key-1', 'ipsec-psk', 'wg-psk', 'wg-private', 'snmp-community', 'portal-pw', 'auth-code-123', 'override-psk', 'ssid-pw', 'bridge-pw', 'ov-pw', 'vrrp-key', 'ks-pw', 'trust-pw', 'hook-secret', 'twilio-token', 'user-token']) {
-            expect(text).not.toContain(secret);
-        }
-    });
-
-    it('keeps public, non-secret values (public keys, ids, names)', () => {
-        const out = redactSecrets({ publicKey: 'wg-public', keyId: 'k1', searchKey: 'abc', ppskProfileId: 'p1' });
-        expect(out).toEqual({ publicKey: 'wg-public', keyId: 'k1', searchKey: 'abc', ppskProfileId: 'p1' });
-    });
-
-    it('masks tokens inside URLs (Home Assistant camera image)', () => {
-        const out = redactSecrets({
-            entity_picture: '/api/camera_proxy/camera.door?token=0123456789abcdef&width=640',
-            attributes: { access_token: 'cam-token' },
-        });
-        expect(out.entity_picture).toBe(`/api/camera_proxy/camera.door?token=${REDACTED}&width=640`);
-        expect(out.attributes.access_token).toBe(REDACTED);
-    });
-
-    it('leaves empty secrets empty, so "is it set?" stays answerable', () => {
-        expect(redactSecrets({ password: '', securityKey: 'x' })).toEqual({ password: '', securityKey: REDACTED });
-    });
-
-    it('does not modify its input', () => {
-        const input = structuredClone(ssidDetail);
-        redactSecrets(input);
-        expect(input).toEqual(ssidDetail);
-    });
-
-    it('handles arrays, nulls and plain strings', () => {
-        expect(redactSecrets([{ password: 'p' }, null, 3])).toEqual([{ password: REDACTED }, null, 3]);
-        expect(redactSecrets('see /x?token=abc')).toBe(`see /x?token=${REDACTED}`);
-        expect(redactSecrets(null)).toBeNull();
-    });
-});
-
-describe('tool responses are redacted', () => {
-    it('toToolResult never carries a secret', () => {
-        const result = toToolResult(ssidDetail);
-        expect(result.content[0].text).not.toContain('HouseWifiPassw0rd!');
-        expect(result.content[0].text).toContain(REDACTED);
-    });
-
-    it('omada_read /wifi/ssids (SSID detail) does not return the Wi-Fi password', async () => {
-        const handlers = new Map<string, (args: unknown, extra: unknown) => Promise<{ content: { text: string }[] }>>();
-        const server = { registerTool: vi.fn((name, _c, h) => handlers.set(name, h)) } as unknown as McpServer;
-        const client = { getSsidDetail: vi.fn().mockResolvedValue(ssidDetail), getSsidList: vi.fn() } as unknown as OmadaClient;
-        registerOmadaGraphTools(server, client);
-
-        const result = await handlers.get('omada_read')!(
-            { path: '/wifi/ssids', params: { wlanId: 'w1', ssidId: 'node-s55' } },
-            { sessionId: 's', http: { authInfo: { extra: { permissions: 0xff } } } }
-        );
-
-        expect(client.getSsidDetail).toHaveBeenCalled();
-        expect(result.content[0].text).not.toContain('HouseWifiPassw0rd!');
-        expect(JSON.parse(result.content[0].text).pskSetting.securityKey).toBe(REDACTED);
-    });
-});

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2023",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "sourceMap": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "allowUnusedLabels": false,
-    "allowUnreachableCode": false
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "tests", "example"]
-}

package/vitest.config.ts

@@ -1,38 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    reporters: ['default'],
-    exclude: [
-      '**/node_modules/**',
-      '**/dist/**',
-      '**/example/**',
-    ],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: [
-        'node_modules/',
-        'dist/',
-        'example/',
-        'tests/',
-        '**/*.test.ts',
-        '**/*.config.ts',
-      ],
-      // Regression FLOOR, not an aspiration. Set just below the measured numbers
-      // (stmts 68.7 / branch 58.3 / funcs 75.4 / lines 69.3 as of v1.4.0) so the
-      // gate catches a DROP in coverage without forcing busywork tests today.
-      // Global (not per-file) by design — per-file 90% gates punish trivial files
-      // and breed assertion-free stubs. Ratchet these UP as real coverage grows;
-      // never lower them to make a red build pass.
-      thresholds: {
-        statements: 68,
-        branches: 57,
-        functions: 74,
-        lines: 68,
-      },
-    },
-  },
-});