@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/src/utils/plainText.ts

@@ -1,48 +0,0 @@
-/**
- * Plain-text validation for user-visible strings we put on the owner's phone.
- *
- * Text is NFC-normalized first (so composed letters such as Romanian ș/ț/ă count
- * as one character), then every character must be a letter, digit, punctuation,
- * a math/currency/modifier symbol, the degree sign, or a plain space; line
- * breaks only where allowed. Everything else is refused, never stripped:
- * emoji and pictographs, control and invisible format characters (zero-width
- * joiners, bidi overrides that make text display differently than it reads),
- * variation selectors and leftover combining marks ("zalgo"), private-use and
- * lone surrogates.
- */
-
-const ALLOWED_CHAR = /^[\p{L}\p{N}\p{P}\p{Sm}\p{Sc}\p{Sk}° ]$/u;
-
-export interface PlainTextOptions {
-    field: string;
-    maxLength: number;
-    allowNewlines?: boolean;
-}
-
-/**
- * @returns the NFC-normalized text
- * @throws Error naming the field and the first offending character
- */
-export function validatePlainText(text: string, options: PlainTextOptions): string {
-    const normalized = text.normalize('NFC');
-    const chars = [...normalized];
-    if (chars.length === 0 || normalized.trim() === '') {
-        throw new Error(`${options.field} must not be empty`);
-    }
-    if (chars.length > options.maxLength) {
-        throw new Error(`${options.field} is ${chars.length} characters; the maximum is ${options.maxLength}`);
-    }
-    for (const [index, char] of chars.entries()) {
-        if (char === '\n' && options.allowNewlines) {
-            continue;
-        }
-        if (!ALLOWED_CHAR.test(char)) {
-            const codePoint = char.codePointAt(0)!.toString(16).toUpperCase().padStart(4, '0');
-            throw new Error(
-                `${options.field} contains a disallowed character U+${codePoint} at position ${index + 1}; ` +
-                'only plain text is accepted (no emoji, control or invisible characters)'
-            );
-        }
-    }
-    return normalized;
-}

package/src/utils/redact.ts

@@ -1,59 +0,0 @@
-/**
- * Redaction of secrets in tool responses.
- *
- * Home Assistant and Omada return secrets inside ordinary read results: the
- * Wi-Fi password (Omada `pskSetting.securityKey`), RADIUS / CoA / SNMP secrets,
- * PPSK and VPN keys, portal passwords, camera access tokens in image URLs. A tool
- * response goes to an AI client and from there into transcripts, so every tool
- * response is passed through `redactSecrets` (see toToolResult).
- *
- * Only non-empty string values under secret-looking names are replaced, with
- * "<redacted>": an empty value stays empty (so "is a password set?" is still
- * answerable), and booleans or numbers under similar names (`hidePwd`,
- * `encryptionPsk`) are left alone. `token=` / `access_token=` query values inside
- * URLs are masked as well. The input is never modified.
- *
- * Applied at the response boundary only, never inside the API clients: internal
- * read-modify-write paths (SSID schedule, site NTP) must see real values.
- */
-
-export const REDACTED = '<redacted>';
-
-/**
- * Secret-looking field names, matched on the whole name or its ending
- * (case-insensitive), from the Omada Open API and Home Assistant responses.
- */
-const SECRET_NAME =
-  /(^key$|password|passwd|pwd$|secret|token$|passphrase|presharedkey|privatekey|securitykey|communitystring|^psk$|md5key|simplekey|authcode|devicekey)/i;
-
-/** Credentials inside URLs, e.g. /api/camera_proxy/camera.door?token=abc123 */
-const URL_SECRET = /([?&](?:access_token|token|key|password|secret)=)[^&#\s"]+/gi;
-
-export function isSecretName(name: string): boolean {
-  return SECRET_NAME.test(name);
-}
-
-export function redactSecrets<T>(value: T): T {
-  return redact(value, new WeakSet()) as T;
-}
-
-function redact(value: unknown, seen: WeakSet<object>): unknown {
-  if (typeof value === 'string') {
-    return value.includes('=') ? value.replace(URL_SECRET, `$1${REDACTED}`) : value;
-  }
-  if (typeof value !== 'object' || value === null) {
-    return value;
-  }
-  if (seen.has(value)) {
-    return '[circular]';
-  }
-  seen.add(value);
-  if (Array.isArray(value)) {
-    return value.map((item) => redact(item, seen));
-  }
-  const out: Record<string, unknown> = {};
-  for (const [key, field] of Object.entries(value as Record<string, unknown>)) {
-    out[key] = typeof field === 'string' && field !== '' && isSecretName(key) ? REDACTED : redact(field, seen);
-  }
-  return out;
-}

package/src/utils/sanitizeError.ts

@@ -1,18 +0,0 @@
-/**
- * Error sanitization for client-facing responses (M6 / OWASP A09:2021).
- *
- * Raw `error.message` values routinely embed infrastructure detail — internal
- * hostnames, ports, filesystem paths, upstream stack fragments, occasionally
- * tokens. None of that belongs in an HTTP response body. Callers should log the
- * full error server-side (via `logger.error`) and send the return of this helper
- * to the client instead.
- *
- * The function intentionally ignores the error's own text: returning a constant
- * generic string is the whole point — there is no "safe subset" of an arbitrary
- * upstream message we can trust to forward.
- */
-const GENERIC_MESSAGE = 'Internal server error';
-
-export function sanitizeError(_error: unknown, fallback: string = GENERIC_MESSAGE): string {
-  return fallback;
-}

package/src/utils/tlsDispatcher.ts

@@ -1,69 +0,0 @@
-/**
- * Per-client TLS dispatcher helper (SEC-CRYPTO / H2).
- *
- * When a client must talk to a host with a self-signed certificate, the ONLY
- * acceptable way to relax certificate validation is to scope it to that single
- * client. The previous implementation toggled the process-global
- * `NODE_TLS_REJECT_UNAUTHORIZED` env var around each `fetch` call, which
- * disables TLS verification for EVERY concurrent outbound request in the
- * process for the duration of the call — a TOCTOU race that silently strips
- * certificate validation from unrelated Home Assistant / AI traffic.
- *
- * Node's global `fetch` (undici) ignores the legacy `agent` option; the
- * supported mechanism is a per-call `dispatcher`. We build one undici Agent per
- * client instance and pass it on every request, leaving the process-global TLS
- * policy untouched.
- *
- * THE PAIRING RULE (v1.7.0, root cause of the 2026-07-10 v1.5.5 incident):
- * a dispatcher built from the npm `undici` package must ONLY be passed to
- * `undici`'s own `fetch` — never to Node's BUILT-IN fetch. The built-in fetch
- * is powered by whatever undici Node bundles, and its dispatch-handler
- * interface drifts across majors: on Node 26 an npm-undici-6 Agent fails with
- * "invalid onError method", surfacing as `fetch failed` on every request (the
- * NAS crash-loop). `tlsAwareFetch` enforces the rule at one choke point.
- */
-
-import { Agent, fetch as undiciFetch, type Dispatcher } from 'undici';
-
-/**
- * `fetch` init augmented with undici's per-request dispatcher option, which is
- * not present in the lib.dom / @types/node `RequestInit` typings.
- */
-export type FetchInitWithDispatcher = RequestInit & { dispatcher?: Dispatcher };
-
-/**
- * Build an undici dispatcher that disables TLS certificate validation, scoped
- * to a single client instance. Returns `undefined` when `strictSsl` is not
- * explicitly disabled, so strict clients carry no dispatcher and use Node's
- * default (validating) global agent.
- *
- * @param strictSsl - When `false`, certificate validation is disabled for this
- *   client only. Any other value (including `undefined`) keeps validation on.
- * @param baseUrl - The client's base URL. For plain-`http:` targets no
- *   dispatcher is created even when `strictSsl` is false: TLS relaxation is
- *   meaningless without TLS, and carrying a dispatcher there only risks the
- *   version-mixing failure described above for zero benefit (this was exactly
- *   the NAS production config that crashed v1.5.5 — http HA + strictSsl=false).
- */
-export function createTlsDispatcher(strictSsl: boolean | undefined, baseUrl?: string): Dispatcher | undefined {
-  if (strictSsl === false) {
-    if (baseUrl !== undefined && baseUrl.trim().toLowerCase().startsWith('http:')) {
-      return undefined;
-    }
-    return new Agent({ connect: { rejectUnauthorized: false } });
-  }
-  return undefined;
-}
-
-/**
- * Fetch enforcing the pairing rule: requests carrying a dispatcher go through
- * undici's own `fetch` (Agent and fetch from the SAME library — compatible on
- * every Node version); requests without one use Node's built-in fetch
- * (unchanged behavior, and unit tests stubbing `global.fetch` keep working).
- */
-export function tlsAwareFetch(url: string, init: FetchInitWithDispatcher): Promise<Response> {
-  if (init.dispatcher) {
-    return undiciFetch(url, init as Parameters<typeof undiciFetch>[1]) as unknown as Promise<Response>;
-  }
-  return fetch(url, init);
-}

package/src/version.ts

@@ -1,5 +0,0 @@
-/**
- * Package version - hardcoded at build time for reliability
- * Keep in sync with package.json version
- */
-export const VERSION = '2.2.1';

package/tests/bdd/automation-creation.spec.ts

@@ -1,214 +0,0 @@
-/**
- * BDD tests for Automation Creation
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } from 'vitest';
-import { AutomationOperations } from '../../src/haClient/automations.js';
-import type { StateOperations } from '../../src/haClient/states.js';
-import type { ServiceOperations } from '../../src/haClient/services.js';
-import type { RequestHandler } from '../../src/haClient/request.js';
-import type { AutomationConfig, AutomationTrigger, AutomationAction } from '../../src/types/index.js';
-
-const feature = await loadFeature('tests/features/automation-creation.feature');
-
-describeFeature(feature, ({ Background, Scenario }) => {
-  // Shared test state
-  let mockStateOps: StateOperations;
-  let mockServiceOps: ServiceOperations;
-  let mockRequest: RequestHandler;
-  let automationOps: AutomationOperations;
-  let automationConfig: Partial<AutomationConfig>;
-  let triggers: AutomationTrigger[];
-  let actions: AutomationAction[];
-  let result: { id: string } | null;
-  let error: Error | null;
-
-  Background(({ Given }) => {
-    Given('a connected Home Assistant client', () => {
-      // Reset state for each scenario
-      automationConfig = {};
-      triggers = [];
-      actions = [];
-      result = null;
-      error = null;
-
-      // Setup mocks
-      mockStateOps = {
-        getStates: vi.fn().mockResolvedValue([]),
-        getState: vi.fn().mockResolvedValue(null),
-      } as unknown as StateOperations;
-
-      mockServiceOps = {
-        callService: vi.fn().mockResolvedValue({ context: { id: 'test' } }),
-      } as unknown as ServiceOperations;
-
-      mockRequest = {
-        post: vi.fn().mockResolvedValue({ result: 'ok' }),
-        get: vi.fn().mockResolvedValue({}),
-        request: vi.fn().mockResolvedValue({}),
-      } as unknown as RequestHandler;
-
-      automationOps = new AutomationOperations(mockStateOps, mockServiceOps, mockRequest);
-    });
-  });
-
-  Scenario('Create a simple time-based automation', ({ Given, When, Then, And }) => {
-    Given('an automation config with alias "Morning Lights"', () => {
-      automationConfig.alias = 'Morning Lights';
-    });
-
-    And('a time trigger at "06:00:00"', () => {
-      triggers.push({
-        platform: 'time',
-        at: '06:00:00',
-      });
-    });
-
-    And('an action to turn on "light.bedroom"', () => {
-      actions.push({
-        service: 'light.turn_on',
-        target: { entity_id: 'light.bedroom' },
-      });
-    });
-
-    When('I create the automation', async () => {
-      try {
-        result = await automationOps.createAutomation({
-          alias: automationConfig.alias!,
-          trigger: triggers,
-          action: actions,
-        });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('the automation should be created successfully', () => {
-      expect(error).toBeNull();
-      expect(result).not.toBeNull();
-      expect(mockRequest.post).toHaveBeenCalled();
-    });
-
-    And('the automation ID should be returned', () => {
-      expect(result?.id).toBeDefined();
-      expect(typeof result?.id).toBe('string');
-    });
-  });
-
-  Scenario('Create an automation with state trigger', ({ Given, When, Then, And }) => {
-    Given('an automation config with alias "Motion Alert"', () => {
-      automationConfig.alias = 'Motion Alert';
-    });
-
-    And('a state trigger for "binary_sensor.motion" changing to "on"', () => {
-      triggers.push({
-        platform: 'state',
-        entity_id: 'binary_sensor.motion',
-        to: 'on',
-      });
-    });
-
-    And('an action to send notification "Motion detected!"', () => {
-      actions.push({
-        service: 'notify.persistent_notification',
-        data: { message: 'Motion detected!' },
-      });
-    });
-
-    When('I create the automation', async () => {
-      try {
-        result = await automationOps.createAutomation({
-          alias: automationConfig.alias!,
-          trigger: triggers,
-          action: actions,
-        });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('the automation should be created successfully', () => {
-      expect(error).toBeNull();
-      expect(result).not.toBeNull();
-    });
-  });
-
-  Scenario('Reject automation without required fields', ({ Given, When, Then }) => {
-    Given('an automation config without alias', () => {
-      // Leave alias undefined
-      automationConfig = {};
-    });
-
-    When('I attempt to create the automation', async () => {
-      // Simulate the tool validation that happens in createAutomation.ts
-      // The actual validation is in the tool layer, not AutomationOperations
-      if (!automationConfig.alias) {
-        error = new Error('alias, trigger, and action are required');
-      }
-    });
-
-    Then('it should fail with error "alias, trigger, and action are required"', () => {
-      expect(error).not.toBeNull();
-      expect(error?.message).toBe('alias, trigger, and action are required');
-    });
-  });
-
-  Scenario('Create automation with multiple actions', ({ Given, When, Then, And }) => {
-    Given('an automation config with alias "Goodnight Routine"', () => {
-      automationConfig.alias = 'Goodnight Routine';
-    });
-
-    And('a time trigger at "23:00:00"', () => {
-      triggers.push({
-        platform: 'time',
-        at: '23:00:00',
-      });
-    });
-
-    And('an action to turn off "light.living_room"', () => {
-      actions.push({
-        service: 'light.turn_off',
-        target: { entity_id: 'light.living_room' },
-      });
-    });
-
-    And('an action to turn off "light.kitchen"', () => {
-      actions.push({
-        service: 'light.turn_off',
-        target: { entity_id: 'light.kitchen' },
-      });
-    });
-
-    And('an action to set "climate.thermostat" to 18 degrees', () => {
-      actions.push({
-        service: 'climate.set_temperature',
-        target: { entity_id: 'climate.thermostat' },
-        data: { temperature: 18 },
-      });
-    });
-
-    When('I create the automation', async () => {
-      try {
-        result = await automationOps.createAutomation({
-          alias: automationConfig.alias!,
-          trigger: triggers,
-          action: actions,
-        });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('the automation should be created successfully', () => {
-      expect(error).toBeNull();
-      expect(result).not.toBeNull();
-
-      // Verify the POST was called with all actions
-      const postCall = (mockRequest.post as ReturnType<typeof vi.fn>).mock.calls[0];
-      const payload = postCall[1];
-      expect(payload.action).toHaveLength(3);
-    });
-  });
-});

package/tests/bdd/automation-management.spec.ts

@@ -1,267 +0,0 @@
-/**
- * BDD tests for Automation Management
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } from 'vitest';
-import { AutomationOperations } from '../../src/haClient/automations.js';
-import type { StateOperations } from '../../src/haClient/states.js';
-import type { ServiceOperations } from '../../src/haClient/services.js';
-import type { RequestHandler } from '../../src/haClient/request.js';
-import type { Entity, Automation } from '../../src/types/index.js';
-
-const feature = await loadFeature('tests/features/automation-management.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let mockStateOps: StateOperations;
-  let mockServiceOps: ServiceOperations;
-  let mockRequest: RequestHandler;
-  let automationOps: AutomationOperations;
-  let automations: Automation[];
-  let automation: Automation | null;
-  let entityId: string;
-  let lastServiceCall: { domain: string; service: string; target?: { entity_id: string }; service_data?: Record<string, unknown> } | null;
-  let lastRequest: { method: string; path: string } | null;
-
-  const mockAutomationEntities: Entity[] = [
-    {
-      entity_id: 'automation.morning_lights',
-      state: 'on',
-      attributes: {
-        friendly_name: 'Morning Lights',
-        last_triggered: '2026-01-08T06:00:00.000Z',
-        description: 'Turn on lights at sunrise',
-        mode: 'single',
-      },
-      last_changed: '2026-01-08T06:00:00.000Z',
-      last_updated: '2026-01-08T06:00:00.000Z',
-      context: { id: 'ctx-1', parent_id: null, user_id: null },
-    },
-    {
-      entity_id: 'automation.night_mode',
-      state: 'off',
-      attributes: {
-        friendly_name: 'Night Mode',
-        last_triggered: null,
-        mode: 'restart',
-      },
-      last_changed: '2026-01-07T22:00:00.000Z',
-      last_updated: '2026-01-08T10:00:00.000Z',
-      context: { id: 'ctx-2', parent_id: null, user_id: null },
-    },
-    {
-      entity_id: 'automation.dynamic_scene',
-      state: 'on',
-      attributes: {
-        friendly_name: 'Dynamic Scene',
-        mode: 'queued',
-      },
-      last_changed: '2026-01-08T09:30:00.000Z',
-      last_updated: '2026-01-08T09:30:00.000Z',
-      context: { id: 'ctx-3', parent_id: null, user_id: null },
-    },
-  ];
-
-  function setupMocks() {
-    lastServiceCall = null;
-    lastRequest = null;
-
-    mockStateOps = {
-      getStates: vi.fn().mockResolvedValue(mockAutomationEntities),
-      getState: vi.fn().mockImplementation(async (id: string) => {
-        return mockAutomationEntities.find(e => e.entity_id === id) || null;
-      }),
-    } as unknown as StateOperations;
-
-    mockServiceOps = {
-      callService: vi.fn().mockImplementation(async (data) => {
-        lastServiceCall = {
-          domain: data.domain,
-          service: data.service,
-          target: data.target,
-          service_data: data.service_data,
-        };
-        return { context: { id: 'test-ctx' } };
-      }),
-    } as unknown as ServiceOperations;
-
-    mockRequest = {
-      post: vi.fn().mockResolvedValue({ result: 'ok' }),
-      get: vi.fn().mockResolvedValue([]),
-      request: vi.fn().mockImplementation(async (path: string, options: { method: string }) => {
-        lastRequest = { method: options.method, path };
-        return {};
-      }),
-    } as unknown as RequestHandler;
-
-    automationOps = new AutomationOperations(mockStateOps, mockServiceOps, mockRequest);
-  }
-
-  Scenario('List all automations', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant with automations', () => {
-      setupMocks();
-    });
-
-    When('I list all automations', async () => {
-      automations = await automationOps.getAutomations();
-    });
-
-    Then('I should get all automation entities', () => {
-      expect(automations).toHaveLength(3);
-    });
-
-    And('each automation should have id, alias, and state', () => {
-      automations.forEach(a => {
-        expect(a.id).toBeDefined();
-        expect(a.alias).toBeDefined();
-        expect(a.state).toMatch(/^(on|off)$/);
-      });
-    });
-  });
-
-  Scenario('Get automation details', ({ Given, When, Then, And }) => {
-    Given('an automation "automation.morning_lights" exists', () => {
-      setupMocks();
-      entityId = 'automation.morning_lights';
-    });
-
-    When('I get the automation details', async () => {
-      automation = await automationOps.getAutomation(entityId);
-    });
-
-    Then('I should see the automation alias "Morning Lights"', () => {
-      expect(automation?.alias).toBe('Morning Lights');
-    });
-
-    And('the state should be "on"', () => {
-      expect(automation?.state).toBe('on');
-    });
-
-    And('the mode should be "single"', () => {
-      expect(automation?.mode).toBe('single');
-    });
-  });
-
-  Scenario('Trigger an automation manually', ({ Given, When, Then, And }) => {
-    Given('an automation "automation.morning_lights" exists', () => {
-      setupMocks();
-      entityId = 'automation.morning_lights';
-    });
-
-    When('I trigger the automation', async () => {
-      await automationOps.triggerAutomation(entityId);
-    });
-
-    Then('the automation.trigger service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('trigger');
-    });
-
-    And('the target should be "automation.morning_lights"', () => {
-      expect(lastServiceCall?.target?.entity_id).toBe('automation.morning_lights');
-    });
-  });
-
-  Scenario('Trigger automation with variables', ({ Given, When, Then, And }) => {
-    Given('an automation "automation.dynamic_scene" exists', () => {
-      setupMocks();
-      entityId = 'automation.dynamic_scene';
-    });
-
-    When('I trigger the automation with variables {"brightness": 100}', async () => {
-      await automationOps.triggerAutomation(entityId, { brightness: 100 });
-    });
-
-    Then('the automation.trigger service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('trigger');
-    });
-
-    And('the variables should be passed', () => {
-      expect(lastServiceCall?.service_data?.variables).toEqual({ brightness: 100 });
-    });
-  });
-
-  Scenario('Enable a disabled automation', ({ Given, When, Then }) => {
-    Given('a disabled automation "automation.night_mode" exists', () => {
-      setupMocks();
-      entityId = 'automation.night_mode';
-    });
-
-    When('I enable the automation', async () => {
-      await automationOps.enableAutomation(entityId);
-    });
-
-    Then('the automation.turn_on service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('turn_on');
-      expect(lastServiceCall?.target?.entity_id).toBe(entityId);
-    });
-  });
-
-  Scenario('Disable an enabled automation', ({ Given, When, Then }) => {
-    Given('an enabled automation "automation.morning_lights" exists', () => {
-      setupMocks();
-      entityId = 'automation.morning_lights';
-    });
-
-    When('I disable the automation', async () => {
-      await automationOps.disableAutomation(entityId);
-    });
-
-    Then('the automation.turn_off service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('turn_off');
-      expect(lastServiceCall?.target?.entity_id).toBe(entityId);
-    });
-  });
-
-  Scenario('Toggle automation state', ({ Given, When, Then }) => {
-    Given('an automation "automation.morning_lights" exists', () => {
-      setupMocks();
-      entityId = 'automation.morning_lights';
-    });
-
-    When('I toggle the automation', async () => {
-      await automationOps.toggleAutomation(entityId);
-    });
-
-    Then('the automation.toggle service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('toggle');
-      expect(lastServiceCall?.target?.entity_id).toBe(entityId);
-    });
-  });
-
-  Scenario('Reload automations from configuration', ({ Given, When, Then }) => {
-    Given('a Home Assistant with automations', () => {
-      setupMocks();
-    });
-
-    When('I reload automations', async () => {
-      await automationOps.reloadAutomations();
-    });
-
-    Then('the automation.reload service should be called', () => {
-      expect(lastServiceCall?.domain).toBe('automation');
-      expect(lastServiceCall?.service).toBe('reload');
-    });
-  });
-
-  Scenario('Delete an automation', ({ Given, When, Then }) => {
-    Given('an automation with ID "1234567890" exists', () => {
-      setupMocks();
-    });
-
-    When('I delete the automation', async () => {
-      await automationOps.deleteAutomation('1234567890');
-    });
-
-    Then('a DELETE request should be made to the config API', () => {
-      expect(lastRequest?.method).toBe('DELETE');
-      expect(lastRequest?.path).toBe('/config/automation/config/1234567890');
-    });
-  });
-});