@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/features/entity-listing.feature

@@ -1,51 +0,0 @@
-Feature: Entity Listing
-  As a Home Assistant user
-  I want to list and filter entities
-  So that I can get an overview of my smart home devices
-
-  Scenario: List all entities without filters
-    Given a Home Assistant instance with multiple entities
-    When I list all entities
-    Then I should get all 4 entities
-
-  Scenario: Filter entities by domain
-    Given a Home Assistant instance with multiple entities
-    When I list entities filtered by domain "light"
-    Then I should only get light entities
-    And the count should be 2
-
-  Scenario: Filter entities by state
-    Given a Home Assistant instance with multiple entities
-    When I list entities filtered by state "on"
-    Then I should only get entities that are "on"
-    And the count should be 2
-
-  Scenario: Filter entities by search query
-    Given a Home Assistant instance with multiple entities
-    When I list entities filtered by search "room"
-    Then I should only get entities matching "room"
-    And the count should be 2
-
-  Scenario: Apply limit to entity list
-    Given a Home Assistant instance with multiple entities
-    When I list entities with limit 2
-    Then I should get at most 2 entities
-
-  Scenario: Combine multiple filters
-    Given a Home Assistant instance with multiple entities
-    When I list entities filtered by domain "light" and state "on"
-    Then I should only get lights that are on
-    And the count should be 1
-
-  Scenario: Get domain summary
-    Given a Home Assistant instance with multiple entities
-    When I get the summary for domain "light"
-    Then the summary should show domain "light"
-    And the total count should be 2
-    And the state breakdown should show 1 "on" and 1 "off"
-
-  Scenario: Get domain summary for non-existent domain
-    Given a Home Assistant instance with multiple entities
-    When I get the summary for domain "vacuum"
-    Then the summary should show domain "vacuum"
-    And the total count should be 0

package/tests/features/entity-search.feature

@@ -1,44 +0,0 @@
-Feature: Entity Search
-  As a Home Assistant user
-  I want to search for entities by name or ID
-  So that I can find and control my devices
-
-  Scenario: Search entities by friendly name
-    Given a Home Assistant instance with multiple entities
-    When I search for "living"
-    Then I should find entities with "living" in their friendly name
-    And the results should include "light.living_room"
-
-  Scenario: Search entities by entity ID
-    Given a Home Assistant instance with multiple entities
-    When I search for "kitchen"
-    Then I should find entities with "kitchen" in their entity ID
-    And the results should include "switch.kitchen"
-
-  Scenario: Search is case insensitive
-    Given a Home Assistant instance with multiple entities
-    When I search for "BEDROOM"
-    Then I should find entities matching "bedroom"
-    And the results should include "light.bedroom"
-
-  Scenario: Search returns multiple matches
-    Given a Home Assistant instance with multiple entities
-    When I search for "light"
-    Then I should find all entities containing "light"
-    And the result count should be 2
-
-  Scenario: Search returns empty for no matches
-    Given a Home Assistant instance with multiple entities
-    When I search for "nonexistent"
-    Then I should find no entities
-
-  Scenario: Get entities by domain
-    Given a Home Assistant instance with multiple entities
-    When I get entities for domain "light"
-    Then I should only get light entities
-    And all entity IDs should start with "light."
-
-  Scenario: Get entities for empty domain
-    Given a Home Assistant instance with multiple entities
-    When I get entities for domain "climate"
-    Then I should find no entities

package/tests/features/history-retrieval.feature

@@ -1,38 +0,0 @@
-Feature: History Retrieval
-  As a Home Assistant user
-  I want to retrieve historical data for my entities
-  So that I can analyze trends and patterns
-
-  Scenario: Get entity history for last 24 hours
-    Given an entity "sensor.temperature" with historical data
-    When I get the history for the last 24 hours
-    Then I should receive historical state changes
-    And the history API should be called with the correct time range
-
-  Scenario: Get entity history with custom time range
-    Given an entity "sensor.temperature" with historical data
-    When I get the history for the last 48 hours
-    Then I should receive historical state changes
-    And the time range should be 48 hours
-
-  Scenario: Get empty history for entity
-    Given an entity with no history
-    When I get the history
-    Then I should receive an empty history array
-
-  Scenario: Get system log entries
-    Given a Home Assistant system log
-    When I get the system log
-    Then I should receive logbook entries
-    And each entry should have timestamp and entity information
-
-  Scenario: Get system log filtered by entity
-    Given a Home Assistant system log
-    When I get the system log for entity "light.living_room"
-    Then I should receive only entries for that entity
-    And the entity filter should be applied
-
-  Scenario: Get system log with custom time range
-    Given a Home Assistant system log
-    When I get the system log for the last 48 hours
-    Then the logbook API should use the 48 hour time range

package/tests/features/notifications.feature

@@ -1,37 +0,0 @@
-Feature: Send Notifications
-  As a Home Assistant user
-  I want to send notifications to my mobile devices
-  So that I can be alerted about important events
-
-  Scenario: Send a simple notification
-    Given a notification message "Hello from MCP!"
-    When I send the notification to "mobile_app_samsung_s25_fe"
-    Then the notification should be sent successfully
-    And the service called should be "notify.mobile_app_samsung_s25_fe"
-
-  Scenario: Send notification with title
-    Given a notification message "Motion detected in garage"
-    And a notification title "Security Alert"
-    When I send the notification to "mobile_app_samsung_s25_fe"
-    Then the notification should be sent successfully
-    And the title should be included in the service data
-
-  Scenario: Send notification with action buttons
-    Given a notification message "Someone is at the door"
-    And an action button "OPEN" with title "Open Door"
-    And an action button "IGNORE" with title "Ignore"
-    When I send the notification to "mobile_app_samsung_s25_fe"
-    Then the notification should be sent successfully
-    And the notification data should contain 2 actions
-
-  Scenario: Send persistent notification (no target)
-    Given a notification message "System update available"
-    When I send the notification without a target
-    Then the notification should be sent to "persistent_notification"
-
-  Scenario: Send high priority notification
-    Given a notification message "Water leak detected!"
-    And priority set to "high"
-    When I send the notification to "mobile_app_samsung_s25_fe"
-    Then the notification should be sent successfully
-    And the notification data should have priority "high"

package/tests/features/service-calls.feature

@@ -1,35 +0,0 @@
-Feature: Service Calls
-  As a Home Assistant user
-  I want to call Home Assistant services
-  So that I can control my devices
-
-  Scenario: Call service with domain and service name
-    Given a Home Assistant connection
-    When I call service "light.turn_on"
-    Then the service should be called successfully
-    And the request should go to "/services/light/turn_on"
-
-  Scenario: Call service with target entity
-    Given a Home Assistant connection
-    When I call service "light.turn_on" targeting "light.living_room"
-    Then the entity_id should be included in the request
-
-  Scenario: Call service with service data
-    Given a Home Assistant connection
-    When I call service "light.turn_on" with brightness 255
-    Then the brightness should be included in the request
-
-  Scenario: Call service targeting multiple entities
-    Given a Home Assistant connection
-    When I call service "light.turn_off" targeting multiple entities
-    Then all entity IDs should be included in the request
-
-  Scenario: Call climate service with temperature
-    Given a Home Assistant connection
-    When I call service "climate.set_temperature" with temperature 22
-    Then the temperature should be included in the request
-
-  Scenario: Restart Home Assistant server
-    Given a Home Assistant connection
-    When I call the restart server operation
-    Then the homeassistant.restart service should be called

package/tests/features/state-retrieval.feature

@@ -1,37 +0,0 @@
-Feature: State Retrieval
-  As a Home Assistant user
-  I want to retrieve entity states
-  So that I can monitor my smart home devices
-
-  Scenario: Get all entity states
-    Given a Home Assistant with multiple entities
-    When I get all states
-    Then I should receive all entity states
-    And the states API should be called
-
-  Scenario: Get state of specific entity
-    Given an entity "light.living_room" exists
-    When I get the state of "light.living_room"
-    Then I should receive the entity state
-    And the state should include entity_id, state, and attributes
-
-  Scenario: Get state of non-existent entity
-    Given an entity does not exist
-    When I get the state of "nonexistent.entity"
-    Then I should receive null
-
-  Scenario: Handle API error gracefully
-    Given the API returns a 500 error
-    When I get the state of "sensor.temperature"
-    Then it should throw an API error
-
-  Scenario: Get all sensors
-    Given a Home Assistant with sensors and other entities
-    When I get all sensors
-    Then I should only receive sensor and binary_sensor entities
-    And other entity types should be excluded
-
-  Scenario: Get sensors when none exist
-    Given a Home Assistant with no sensors
-    When I get all sensors
-    Then I should receive an empty array

package/tests/fixtures/openapi-default-slice.json

@@ -1,290 +0,0 @@
-{
-  "openapi": "3.1.0",
-  "info": {
-    "title": "Home Assistant MCP Tools",
-    "description": "MCP server for Home Assistant - exposes entity states and service calls",
-    "version": "1.6.0"
-  },
-  "servers": [
-    {
-      "url": "http://__BASE_URL__"
-    }
-  ],
-  "paths": {
-    "/api/states": {
-      "get": {
-        "operationId": "getStates",
-        "summary": "Get all entity states from Home Assistant",
-        "responses": {
-          "200": {
-            "description": "List of all entity states",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/EntityState"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/states/{entity_id}": {
-      "get": {
-        "operationId": "getState",
-        "summary": "Get state of a specific entity",
-        "parameters": [
-          {
-            "name": "entity_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Entity ID (e.g., light.living_room)"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Entity state",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/EntityState"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/services/{domain}/{service}": {
-      "post": {
-        "operationId": "callService",
-        "summary": "Call a Home Assistant service",
-        "parameters": [
-          {
-            "name": "domain",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Service domain (e.g., light, switch)"
-          },
-          {
-            "name": "service",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Service name (e.g., turn_on, turn_off)"
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "entity_id": {
-                    "type": "string",
-                    "description": "Target entity ID"
-                  },
-                  "data": {
-                    "type": "object",
-                    "description": "Service data"
-                  }
-                }
-              }
-            }
-          }
-        },
-        "responses": {
-          "200": {
-            "description": "Service call result"
-          }
-        }
-      }
-    },
-    "/api/sensors": {
-      "get": {
-        "operationId": "getAllSensors",
-        "summary": "Get all sensor and binary_sensor states",
-        "responses": {
-          "200": {
-            "description": "List of sensor states",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/EntityState"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/entities/{domain}": {
-      "get": {
-        "operationId": "getEntitiesByDomain",
-        "summary": "Get all entities for a specific domain",
-        "parameters": [
-          {
-            "name": "domain",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Domain name (e.g., light, sensor)"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "List of entities in domain",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/EntityState"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/search": {
-      "get": {
-        "operationId": "searchEntities",
-        "summary": "Search entities by name or ID",
-        "parameters": [
-          {
-            "name": "q",
-            "in": "query",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Search query"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Matching entities",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/EntityState"
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/history/{entity_id}": {
-      "get": {
-        "operationId": "getHistory",
-        "summary": "Get historical data for an entity",
-        "parameters": [
-          {
-            "name": "entity_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string"
-            },
-            "description": "Entity ID"
-          },
-          {
-            "name": "hours",
-            "in": "query",
-            "schema": {
-              "type": "number",
-              "default": 24
-            },
-            "description": "Hours of history"
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Historical data",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/version": {
-      "get": {
-        "operationId": "getVersion",
-        "summary": "Get Home Assistant version information",
-        "responses": {
-          "200": {
-            "description": "Version information",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "ha_version": {
-                      "type": "string",
-                      "description": "Home Assistant version"
-                    },
-                    "mcp_version": {
-                      "type": "string",
-                      "description": "MCP server version"
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "schemas": {
-      "EntityState": {
-        "type": "object",
-        "properties": {
-          "entity_id": {
-            "type": "string"
-          },
-          "state": {
-            "type": "string"
-          },
-          "attributes": {
-            "type": "object"
-          },
-          "last_changed": {
-            "type": "string"
-          },
-          "last_updated": {
-            "type": "string"
-          }
-        }
-      }
-    }
-  }
-}

package/tests/haClient/automationTrace.test.ts

@@ -1,59 +0,0 @@
-/**
- * getAutomationTrace goes over the WebSocket (`trace/list`), keyed by the
- * automation's config id — there is no REST trace endpoint in Home Assistant.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-
-import { AutomationOperations } from '../../src/haClient/automations.js';
-import type { StateOperations } from '../../src/haClient/states.js';
-
-function setup(state: unknown, traces: unknown = []) {
-    const stateOps = { getState: vi.fn().mockResolvedValue(state) } as unknown as StateOperations;
-    const wsCommand = vi.fn().mockResolvedValue(traces);
-    const request = { get: vi.fn() };
-    const ops = new AutomationOperations(stateOps, undefined, request as never, wsCommand as never);
-    return { ops, wsCommand, request };
-}
-
-const automation = (attributes: Record<string, unknown>) => ({ entity_id: 'automation.relay', state: 'on', attributes });
-
-const run = (id: string, start: string) => ({ run_id: id, timestamp: { start, finish: start }, trigger: 'state of sensor.x' });
-
-describe('AutomationOperations.getAutomationTrace', () => {
-    it('lists traces by the automation id attribute, newest first, over the WebSocket only', async () => {
-        const { ops, wsCommand, request } = setup(automation({ id: '1700000000000' }), [
-            run('a', '2026-10-07T08:00:00Z'),
-            run('c', '2026-10-07T10:00:00Z'),
-            run('b', '2026-10-07T09:00:00Z'),
-        ]);
-
-        const traces = await ops.getAutomationTrace('automation.relay');
-
-        expect(wsCommand).toHaveBeenCalledWith({ type: 'trace/list', domain: 'automation', item_id: '1700000000000' });
-        expect(traces.map((t) => t.run_id)).toEqual(['c', 'b', 'a']);
-        expect(request.get).not.toHaveBeenCalled();
-    });
-
-    it('returns at most `limit` runs (default 5)', async () => {
-        const many = Array.from({ length: 8 }, (_, i) => run(String(i), `2026-10-07T0${i}:00:00Z`));
-        const { ops } = setup(automation({ id: 7 }), many);
-
-        expect(await ops.getAutomationTrace('automation.relay')).toHaveLength(5);
-        expect((await ops.getAutomationTrace('automation.relay', 2)).map((t) => t.run_id)).toEqual(['7', '6']);
-    });
-
-    it('explains that a YAML automation without an id has no traces', async () => {
-        const { ops, wsCommand } = setup(automation({ friendly_name: 'Relay' }));
-
-        await expect(ops.getAutomationTrace('automation.relay')).rejects.toThrow(/has no 'id'.*no traces/);
-        expect(wsCommand).not.toHaveBeenCalled();
-    });
-
-    it('reports an unknown automation', async () => {
-        const { ops, wsCommand } = setup(null);
-
-        await expect(ops.getAutomationTrace('automation.nope')).rejects.toThrow('Automation automation.nope not found');
-        expect(wsCommand).not.toHaveBeenCalled();
-    });
-});