homebridge-securitysystem 0.0.1-matter

package/src/tests/trip-handler.test.ts

@@ -0,0 +1,244 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import { EventType } from '../types/event-type.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+
+function makeState(overrides: Partial<SystemState> = {}): SystemState {
+  return {
+    currentState: SecurityState.HOME,
+    targetState: SecurityState.HOME,
+    defaultState: SecurityState.OFF,
+    availableTargetStates: [SecurityState.HOME, SecurityState.AWAY, SecurityState.NIGHT, SecurityState.OFF],
+    isArming: false,
+    isTripping: false,
+    isKnocked: false,
+    serverAuthenticationAttempts: 0,
+    pausedCurrentState: null,
+    armingLocks: { global: false, home: false, away: false, night: false },
+    modeAwayExtended: false,
+    ...overrides,
+  };
+}
+
+function makeOptions(overrides: Partial<SecuritySystemOptions> = {}): SecuritySystemOptions {
+  return {
+    overrideOff: false,
+    doubleKnock: false,
+    doubleKnockSeconds: 90,
+    doubleKnockModes: [],
+    triggerSeconds: 0,
+    homeTriggerSeconds: null,
+    awayTriggerSeconds: null,
+    nightTriggerSeconds: null,
+    modeAwayExtendedSwitchTriggerSeconds: null,
+    trippedMotionSensor: false,
+    trippedMotionSensorSeconds: 5,
+    homeDoubleKnockSeconds: null,
+    awayDoubleKnockSeconds: null,
+    nightDoubleKnockSeconds: null,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+// ── TripHandler tests ─────────────────────────────────────────────────────────
+
+describe('TripHandler', async () => {
+  const { TripHandler } = await import('../handlers/trip-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  let state: SystemState;
+  let bus: InstanceType<typeof EventBusService>;
+  let tripHandler: any;
+  const mockSensorHandler = {
+    pulseTrippedMotionSensor: vi.fn(),
+    setTrippedMotionSensor: vi.fn(),
+    resetTrippedMotionSensor: vi.fn(),
+  };
+  const mockTimers = {
+    setTriggerTimer: vi.fn(), clearTriggerTimer: vi.fn(), isTriggerRunning: vi.fn().mockReturnValue(false),
+    setTrippedInterval: vi.fn(), clearTrippedInterval: vi.fn(),
+    setDoubleKnockTimer: vi.fn(), clearDoubleKnockTimer: vi.fn(),
+    clearAll: vi.fn(),
+  } as any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    state = makeState({ currentState: SecurityState.HOME });
+    bus = new EventBusService();
+    const mockLog = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    tripHandler = new TripHandler(state, makeOptions(), mockLog as any, bus, mockSensorHandler as any, mockTimers);
+  });
+
+  it('blocks trip when system is disarmed (not overriding)', () => {
+    state.currentState = SecurityState.OFF;
+    const result = tripHandler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('Trip Switch (Not armed): system is disarmed and override is not enabled');
+  });
+
+  it('blocks trip when arming is in progress', () => {
+    state.isArming = true;
+    const result = tripHandler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('Trip Switch (Still arming): arm delay countdown is still in progress');
+  });
+
+  it('blocks trip when already triggered', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    const result = tripHandler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('Security System (Already triggered): alarm is already active');
+  });
+
+  it('blocks trip when trigger timeout is already running', () => {
+    state.isTripping = true;
+    const result = tripHandler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('Security System (Already tripped): trigger delay countdown is already running');
+    state.isTripping = false;
+  });
+
+  it('allows trip when system is armed (HOME mode)', () => {
+    state.currentState = SecurityState.HOME;
+    const result = tripHandler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+    expect(result.success).toBe(true);
+  });
+
+  describe('tripped motion sensor', () => {
+    it('starts steady-on when trippedMotionSensorSeconds = 0', () => {
+      const handler = new TripHandler(
+        state,
+        makeOptions({ trippedMotionSensor: true, trippedMotionSensorSeconds: 0 }),
+        { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
+        bus, mockSensorHandler as any, mockTimers,
+      );
+
+      handler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+
+      expect(mockSensorHandler.setTrippedMotionSensor).toHaveBeenCalledWith(true);
+      expect(mockSensorHandler.pulseTrippedMotionSensor).not.toHaveBeenCalled();
+      expect(mockTimers.setTrippedInterval).not.toHaveBeenCalled();
+    });
+
+    it('pulses with interval when trippedMotionSensorSeconds > 0', () => {
+      const handler = new TripHandler(
+        state,
+        makeOptions({ trippedMotionSensor: true, trippedMotionSensorSeconds: 10 }),
+        { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
+        bus, mockSensorHandler as any, mockTimers,
+      );
+
+      handler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+
+      expect(mockSensorHandler.pulseTrippedMotionSensor).toHaveBeenCalled();
+      expect(mockTimers.setTrippedInterval).toHaveBeenCalledWith(10000, expect.any(Function));
+      expect(mockSensorHandler.setTrippedMotionSensor).not.toHaveBeenCalled();
+    });
+
+    it('resets tripped sensor on cancelTrip', () => {
+      const handler = new TripHandler(
+        state,
+        makeOptions({ trippedMotionSensor: true }),
+        { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
+        bus, mockSensorHandler as any, mockTimers,
+      );
+
+      handler.updateTripSwitch(false, OriginType.REGULAR_SWITCH, false);
+
+      expect(mockSensorHandler.resetTrippedMotionSensor).toHaveBeenCalled();
+    });
+  });
+
+  it('cancels trip and emits TRIP_CANCELLED', () => {
+    const emitted: unknown[] = [];
+    bus.on(EventType.TRIP_CANCELLED, (payload) => emitted.push(payload));
+
+    tripHandler.updateTripSwitch(false, OriginType.REGULAR_SWITCH, false);
+
+    expect(emitted).toHaveLength(1);
+  });
+
+  it('emits TRIP_CANCELLED with stateChanged=false when trip cancelled while triggered', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    let payload: any;
+    bus.on(EventType.TRIP_CANCELLED, (p) => {
+      payload = p;
+    });
+
+    tripHandler.updateTripSwitch(false, OriginType.REGULAR_SWITCH, false);
+
+    expect(payload).toBeDefined();
+    expect(payload.stateChanged).toBe(false);
+  });
+
+  it('emits TRIP_CANCELLED with stateChanged=true when state has changed', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    let payload: any;
+    bus.on(EventType.TRIP_CANCELLED, (p) => {
+      payload = p;
+    });
+
+    tripHandler.updateTripSwitch(false, OriginType.INTERNAL, true);
+
+    expect(payload).toBeDefined();
+    expect(payload.stateChanged).toBe(true);
+  });
+
+  it('uses the extended trigger seconds when armed away-extended', () => {
+    state.currentState = SecurityState.AWAY;
+    state.modeAwayExtended = true;
+    const handler = new TripHandler(
+      state,
+      makeOptions({ modeAwayExtendedSwitchTriggerSeconds: 45 }),
+      { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
+      bus, mockSensorHandler as any, mockTimers,
+    );
+
+    handler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+
+    expect(mockTimers.setTriggerTimer).toHaveBeenCalledWith(45000, expect.any(Function));
+  });
+
+  it('uses the regular away trigger seconds when not extended', () => {
+    state.currentState = SecurityState.AWAY;
+    const handler = new TripHandler(
+      state,
+      makeOptions({ modeAwayExtendedSwitchTriggerSeconds: 45, awayTriggerSeconds: 10 }),
+      { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
+      bus, mockSensorHandler as any, mockTimers,
+    );
+
+    handler.updateTripSwitch(true, OriginType.REGULAR_SWITCH, false);
+
+    expect(mockTimers.setTriggerTimer).toHaveBeenCalledWith(10000, expect.any(Function));
+  });
+
+  it('triggerIfModeSet allows when current mode matches required', () => {
+    state.currentState = SecurityState.HOME;
+    const result = tripHandler.triggerIfModeSet(SecurityState.HOME, true);
+    expect(result.success).toBe(true);
+  });
+
+  it('triggerIfModeSet blocks when current mode does not match', () => {
+    state.currentState = SecurityState.AWAY;
+    const result = tripHandler.triggerIfModeSet(SecurityState.HOME, true);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('mode not set');
+  });
+
+  it('triggerIfModeSet allows a trip while triggered when the target matches', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    state.targetState = SecurityState.HOME;
+    const result = tripHandler.triggerIfModeSet(SecurityState.HOME, true);
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('Security System (Already triggered): alarm is already active');
+  });
+
+  it('custom trip switch cancellation works with triggerIfModeSet', () => {
+    state.currentState = SecurityState.HOME;
+    const result = tripHandler.triggerIfModeSet(SecurityState.HOME, false);
+    expect(result.success).toBe(true);
+  });
+});

package/src/timers/timer-manager.ts

@@ -0,0 +1,141 @@
+import type { Logging } from 'homebridge';
+
+type TimerHandle = ReturnType<typeof setTimeout> | null;
+type IntervalHandle = ReturnType<typeof setInterval> | null;
+
+/**
+ * Centralised owner of all timer and interval handles used by the security
+ * system. Handlers call set/clear methods here rather than mutating the shared
+ * SystemState directly, giving a single place where timer lifecycle is managed.
+ */
+export class TimerManager {
+  private armTimer: TimerHandle = null;
+  private pauseTimer: TimerHandle = null;
+  private triggerTimer: TimerHandle = null;
+  private doubleKnockTimer: TimerHandle = null;
+  private resetTimer: TimerHandle = null;
+  private trippedInterval: IntervalHandle = null;
+
+  constructor(private readonly log: Logging) {}
+
+  // ── Arm timer ──────────────────────────────────────────────────────────────
+
+  setArmTimer(ms: number, cb: () => void): void {
+    this.clearArmTimer();
+    this.armTimer = setTimeout(() => {
+      this.armTimer = null;
+      cb();
+    }, ms);
+  }
+
+  clearArmTimer(): void {
+    if (this.armTimer) {
+      clearTimeout(this.armTimer);
+      this.armTimer = null;
+      this.log.debug('Arming timeout (Cleared)');
+    }
+  }
+
+  // ── Trigger timer ──────────────────────────────────────────────────────────
+
+  setTriggerTimer(ms: number, cb: () => void): void {
+    this.clearTriggerTimer();
+    this.triggerTimer = setTimeout(() => {
+      this.triggerTimer = null;
+      cb();
+    }, ms);
+  }
+
+  clearTriggerTimer(): void {
+    if (this.triggerTimer) {
+      clearTimeout(this.triggerTimer);
+      this.triggerTimer = null;
+      this.log.debug('Trigger timeout (Cleared)');
+    }
+  }
+
+  isTriggerRunning(): boolean {
+    return this.triggerTimer !== null;
+  }
+
+  // ── Pause timer ────────────────────────────────────────────────────────────
+
+  setPauseTimer(ms: number, cb: () => void): void {
+    this.clearPauseTimer();
+    this.pauseTimer = setTimeout(() => {
+      this.pauseTimer = null;
+      cb();
+    }, ms);
+  }
+
+  clearPauseTimer(): void {
+    if (this.pauseTimer) {
+      clearTimeout(this.pauseTimer);
+      this.pauseTimer = null;
+      this.log.debug('Pause timeout (Cleared)');
+    }
+  }
+
+  // ── Double-knock timer ─────────────────────────────────────────────────────
+
+  setDoubleKnockTimer(ms: number, cb: () => void): void {
+    this.clearDoubleKnockTimer();
+    this.doubleKnockTimer = setTimeout(() => {
+      this.doubleKnockTimer = null;
+      cb();
+    }, ms);
+  }
+
+  clearDoubleKnockTimer(): void {
+    if (this.doubleKnockTimer) {
+      clearTimeout(this.doubleKnockTimer);
+      this.doubleKnockTimer = null;
+      this.log.debug('Double-knock timeout (Cleared)');
+    }
+  }
+
+  // ── Reset timer ────────────────────────────────────────────────────────────
+
+  setResetTimer(ms: number, cb: () => void): void {
+    this.clearResetTimer();
+    this.resetTimer = setTimeout(() => {
+      this.resetTimer = null;
+      cb();
+    }, ms);
+  }
+
+  clearResetTimer(): void {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = null;
+      this.log.debug('Reset timeout (Cleared)');
+    }
+  }
+
+  // ── Tripped motion sensor interval ─────────────────────────────────────────
+
+  setTrippedInterval(ms: number, cb: () => void): void {
+    this.clearTrippedInterval();
+    this.trippedInterval = setInterval(cb, ms);
+  }
+
+  clearTrippedInterval(): void {
+    if (this.trippedInterval) {
+      clearInterval(this.trippedInterval);
+      this.trippedInterval = null;
+      this.log.debug('Tripped interval (Cleared)');
+    }
+  }
+
+  // ── Bulk clear ─────────────────────────────────────────────────────────────
+
+  /** Clears every active timer and interval. */
+  clearAll(): void {
+    this.clearTriggerTimer();
+    this.clearArmTimer();
+    this.clearTrippedInterval();
+    this.clearDoubleKnockTimer();
+    this.clearPauseTimer();
+    this.clearResetTimer();
+  }
+}

package/src/types/event-payload-map-type.ts

@@ -0,0 +1,25 @@
+import { EventType } from './event-type.js';
+import type {
+  TargetChangedPayload,
+  CurrentChangedPayload,
+  ArmingPayload,
+  WarningPayload,
+  TriggerFiredPayload,
+  TripCancelledPayload,
+  SensorStateChangedPayload,
+  EmptyPayload,
+} from './event-type.js';
+
+/** Maps each EventType to the payload type emitted with it. */
+export type EventPayloadMap = {
+  [EventType.TARGET_CHANGED]: TargetChangedPayload;
+  [EventType.CURRENT_CHANGED]: CurrentChangedPayload;
+  [EventType.ARMING]: ArmingPayload;
+  [EventType.WARNING]: WarningPayload;
+  [EventType.RESET_TRIP_SWITCHES]: EmptyPayload;
+  [EventType.RESET_MODE_SWITCHES]: EmptyPayload;
+  [EventType.UPDATE_MODE_SWITCHES]: EmptyPayload;
+  [EventType.SENSOR_STATE_CHANGED]: SensorStateChangedPayload;
+  [EventType.TRIGGER_FIRED]: TriggerFiredPayload;
+  [EventType.TRIP_CANCELLED]: TripCancelledPayload;
+};

package/src/types/event-type.ts

@@ -0,0 +1,61 @@
+import type { SecurityState } from './security-state-type.js';
+import type { OriginType } from './origin-type.js';
+import type { SensorKind } from './sensor-kind-type.js';
+
+/** All domain events emitted on the EventBusService. */
+export enum EventType {
+  TARGET_CHANGED = 'target-changed',
+  CURRENT_CHANGED = 'current-changed',
+  ARMING = 'arming',
+  WARNING = 'warning',
+
+  // Emitted by StateHandler before TARGET_CHANGED/CURRENT_CHANGED;
+  // consumed by TripHandler and SwitchHandler to reset their own state.
+  RESET_TRIP_SWITCHES = 'reset-trip-switches',
+  RESET_MODE_SWITCHES = 'reset-mode-switches',
+  UPDATE_MODE_SWITCHES = 'update-mode-switches',
+
+  // Emitted by SensorHandler whenever a motion sensor value changes;
+  // consumed by MatterService to push occupancy state to Matter.
+  SENSOR_STATE_CHANGED = 'sensor-state-changed',
+
+  // Emitted by TripHandler; consumed by SecuritySystem which calls into StateHandler.
+  TRIGGER_FIRED = 'trigger-fired',
+  TRIP_CANCELLED = 'trip-cancelled',
+}
+
+export interface TargetChangedPayload {
+  state: SecurityState;
+  origin: OriginType;
+}
+
+export interface CurrentChangedPayload {
+  state: SecurityState;
+  origin: OriginType;
+}
+
+export interface ArmingPayload {
+  state: SecurityState;
+}
+
+export interface WarningPayload {
+  origin: OriginType;
+  triggerSeconds: number;
+}
+
+export interface TriggerFiredPayload {
+  origin: OriginType;
+}
+
+export interface TripCancelledPayload {
+  origin: OriginType;
+  stateChanged: boolean;
+}
+
+export interface SensorStateChangedPayload {
+  sensor: SensorKind;
+  value: boolean;
+}
+
+/** Empty payload for internal coordination events. */
+export type EmptyPayload = Record<string, never>;

package/src/types/matter-accessory-key-type.ts

@@ -0,0 +1,33 @@
+/**
+ * Stable identifier for every Matter accessory the plugin can publish.
+ * Custom trip switches carry their mode and index, e.g. `trip-custom-away-0`.
+ */
+export type MatterAccessoryKey =
+  // Trip switches
+  | 'trip'
+  | 'trip-home'
+  | 'trip-away'
+  | 'trip-night'
+  | 'trip-override'
+  | `trip-custom-home-${number}`
+  | `trip-custom-away-${number}`
+  | `trip-custom-night-${number}`
+  // Mode switches
+  | 'mode-home'
+  | 'mode-away'
+  | 'mode-night'
+  | 'mode-off'
+  | 'mode-away-extended'
+  | 'mode-pause'
+  // Arming lock switches
+  | 'arming-lock'
+  | 'arming-lock-home'
+  | 'arming-lock-away'
+  | 'arming-lock-night'
+  // Motion sensors
+  | 'sensor-arming'
+  | 'sensor-tripped'
+  | 'sensor-reset';
+
+/** All fixed switch keys — everything except the dynamic custom trip switches. */
+export type FixedMatterSwitchKey = Exclude<MatterAccessoryKey, `trip-custom-${string}` | `sensor-${string}`>;

package/src/types/mode-type.ts

@@ -0,0 +1,4 @@
+/**
+ * Human-readable mode strings used in commands and webhooks.
+ */
+export type Mode = 'off' | 'home' | 'away' | 'night' | 'triggered' | 'warning' | 'lock' | 'unknown';

package/src/types/origin-type.ts

@@ -0,0 +1,9 @@
+/**
+ * Identifies the source of a state change or trip action.
+ */
+export enum OriginType {
+  REGULAR_SWITCH = 0,
+  OVERRIDE_SWITCH = 1,
+  INTERNAL = 3,
+  EXTERNAL = 4,
+}

package/src/types/security-state-type.ts

@@ -0,0 +1,11 @@
+/**
+ * Numeric states matching HomeKit's SecuritySystemCurrentState &
+ * SecuritySystemTargetState characteristic values.
+ */
+export enum SecurityState {
+  HOME = 0,      // STAY_ARM
+  AWAY = 1,      // AWAY_ARM
+  NIGHT = 2,     // NIGHT_ARM
+  OFF = 3,       // DISARMED / DISARM
+  TRIGGERED = 4, // ALARM_TRIGGERED (current state only)
+}

package/src/types/sensor-kind-type.ts

@@ -0,0 +1,2 @@
+/** Identifies one of the three motion sensors the plugin can expose. */
+export type SensorKind = 'arming' | 'tripped' | 'reset';

package/src/types/service-result-type.ts

@@ -0,0 +1,4 @@
+export type ServiceResult = {
+  success: boolean;
+  reason?: string;
+};

package/src/utils/arming-util.ts

@@ -0,0 +1,44 @@
+import { SecurityState } from '../types/security-state-type.js';
+
+/** Subset of SecuritySystemOptions needed for arming delay resolution. */
+interface ArmingOptions {
+  armSeconds: number;
+  homeArmSeconds: number | null;
+  awayArmSeconds: number | null;
+  nightArmSeconds: number | null;
+}
+
+/** Subset of SystemState needed for arming delay resolution. */
+interface ArmingState {
+  currentState: SecurityState;
+}
+
+/**
+ * Resolves the arming delay in seconds for the given target state.
+ * Returns 0 when disarming (OFF) or when currently triggered.
+ * Falls back to the global `armSeconds` when no mode-specific override is set.
+ */
+export function getArmingSeconds(
+  state: ArmingState,
+  options: ArmingOptions,
+  targetState: SecurityState,
+): number {
+  const isTriggered = state.currentState === SecurityState.TRIGGERED;
+  const isOff = targetState === SecurityState.OFF;
+
+  if (isTriggered || isOff) {
+    return 0;
+  }
+
+  if (targetState === SecurityState.HOME && options.homeArmSeconds !== null) {
+    return options.homeArmSeconds;
+  }
+  if (targetState === SecurityState.AWAY && options.awayArmSeconds !== null) {
+    return options.awayArmSeconds;
+  }
+  if (targetState === SecurityState.NIGHT && options.nightArmSeconds !== null) {
+    return options.nightArmSeconds;
+  }
+
+  return options.armSeconds;
+}

package/src/utils/state-util.ts

@@ -0,0 +1,32 @@
+import { SecurityState } from '../types/security-state-type.js';
+import type { Mode } from '../types/mode-type.js';
+
+/** Converts a SecurityState value to its human-readable mode string. */
+export function stateToMode(state: SecurityState | string): Mode {
+  switch (state) {
+  case SecurityState.TRIGGERED: return 'triggered';
+  case SecurityState.HOME: return 'home';
+  case SecurityState.AWAY: return 'away';
+  case SecurityState.NIGHT: return 'night';
+  case SecurityState.OFF: return 'off';
+  case 'lock': return 'lock';
+  case 'warning': return 'warning';
+  default: return 'unknown';
+  }
+}
+
+/** Converts a mode string to its corresponding SecurityState value (-1 if unknown). */
+export function modeToState(mode: string): SecurityState {
+  switch (mode) {
+  case 'home': return SecurityState.HOME;
+  case 'away': return SecurityState.AWAY;
+  case 'night': return SecurityState.NIGHT;
+  case 'off': return SecurityState.OFF;
+  default: return -1 as SecurityState;
+  }
+}
+
+/** Capitalises the first letter of a string. */
+export function capitalise(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "DOM",
+      "ES2022"
+    ],
+    "rootDir": "src",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "declaration": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "homebridge-ui",
+    "src"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/tests/**/*.test.ts'],
+    environment: 'node',
+  },
+});