@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/src/haClient/automations.ts

@@ -1,261 +0,0 @@
-/**
- * Automation Operations for Home Assistant API
- * Handles automation listing and management
- */
-
-import type { Automation, AutomationConfig, ServiceCallResponse } from '../types/index.js';
-import { logger } from '../utils/logger.js';
-import type { StateOperations } from './states.js';
-import type { ServiceOperations } from './services.js';
-import type { RequestHandler } from './request.js';
-import type { HaWebSocketCommand } from './wsCommand.js';
-
-/** One run of an automation, as `trace/list` summarizes it. */
-export interface AutomationTraceSummary {
-  run_id: string;
-  state?: string;
-  script_execution?: string | null;
-  last_step?: string | null;
-  error?: string;
-  trigger?: string;
-  timestamp?: { start: string; finish: string | null };
-  [key: string]: unknown;
-}
-
-/**
- * Automation-related operations for the Home Assistant API.
- */
-export class AutomationOperations {
-  constructor(
-    private readonly stateOps: StateOperations,
-    private readonly serviceOps?: ServiceOperations,
-    private readonly request?: RequestHandler,
-    private readonly wsCommand?: HaWebSocketCommand
-  ) {}
-
-  /**
-   * Get all automations
-   */
-  async getAutomations(): Promise<Automation[]> {
-    logger.debug('Fetching automations');
-
-    const allStates = await this.stateOps.getStates();
-    const automations = allStates
-      .filter(entity => entity.entity_id.startsWith('automation.'))
-      .map(entity => ({
-        id: entity.entity_id,
-        alias: String(entity.attributes.friendly_name || entity.entity_id.replace('automation.', '')),
-        state: entity.state as 'on' | 'off',
-        last_triggered: entity.attributes.last_triggered as string | null,
-        description: entity.attributes.description as string | undefined,
-        mode: entity.attributes.mode as Automation['mode'],
-      }));
-
-    logger.info('Fetched automations', { count: automations.length });
-    return automations;
-  }
-
-  /**
-   * Get a single automation by entity_id
-   */
-  async getAutomation(entityId: string): Promise<Automation | null> {
-    logger.debug('Fetching automation', { entityId });
-
-    const state = await this.stateOps.getState(entityId);
-    if (!state || !entityId.startsWith('automation.')) {
-      return null;
-    }
-
-    return {
-      id: state.entity_id,
-      alias: String(state.attributes.friendly_name || state.entity_id.replace('automation.', '')),
-      state: state.state as 'on' | 'off',
-      last_triggered: state.attributes.last_triggered as string | null,
-      description: state.attributes.description as string | undefined,
-      mode: state.attributes.mode as Automation['mode'],
-    };
-  }
-
-  /**
-   * Trigger an automation manually
-   */
-  async triggerAutomation(entityId: string, variables?: Record<string, unknown>): Promise<ServiceCallResponse> {
-    if (!this.serviceOps) {
-      throw new Error('ServiceOperations not available');
-    }
-
-    logger.info('Triggering automation', { entityId, variables });
-
-    return this.serviceOps.callService({
-      domain: 'automation',
-      service: 'trigger',
-      target: { entity_id: entityId },
-      service_data: variables ? { variables } : undefined,
-    });
-  }
-
-  /**
-   * Enable an automation
-   */
-  async enableAutomation(entityId: string): Promise<ServiceCallResponse> {
-    if (!this.serviceOps) {
-      throw new Error('ServiceOperations not available');
-    }
-
-    logger.info('Enabling automation', { entityId });
-
-    return this.serviceOps.callService({
-      domain: 'automation',
-      service: 'turn_on',
-      target: { entity_id: entityId },
-    });
-  }
-
-  /**
-   * Disable an automation
-   */
-  async disableAutomation(entityId: string): Promise<ServiceCallResponse> {
-    if (!this.serviceOps) {
-      throw new Error('ServiceOperations not available');
-    }
-
-    logger.info('Disabling automation', { entityId });
-
-    return this.serviceOps.callService({
-      domain: 'automation',
-      service: 'turn_off',
-      target: { entity_id: entityId },
-    });
-  }
-
-  /**
-   * Toggle an automation (enable if disabled, disable if enabled)
-   */
-  async toggleAutomation(entityId: string): Promise<ServiceCallResponse> {
-    if (!this.serviceOps) {
-      throw new Error('ServiceOperations not available');
-    }
-
-    logger.info('Toggling automation', { entityId });
-
-    return this.serviceOps.callService({
-      domain: 'automation',
-      service: 'toggle',
-      target: { entity_id: entityId },
-    });
-  }
-
-  /**
-   * Reload all automations from configuration
-   */
-  async reloadAutomations(): Promise<void> {
-    if (!this.serviceOps) {
-      throw new Error('ServiceOperations not available');
-    }
-
-    logger.info('Reloading automations');
-
-    await this.serviceOps.callService({
-      domain: 'automation',
-      service: 'reload',
-    });
-  }
-
-  /**
-   * Create a new automation via the config API
-   * Note: Requires automation: !include automations.yaml in configuration.yaml
-   */
-  async createAutomation(config: AutomationConfig): Promise<{ id: string }> {
-    if (!this.request) {
-      throw new Error('RequestHandler not available');
-    }
-
-    // Generate a unique ID for the automation (timestamp-based like HA UI does)
-    const automationId = config.id || String(Date.now());
-
-    logger.info('Creating automation', { alias: config.alias, id: automationId });
-
-    // POST to /config/automation/config/{id} - the ID must be in the URL path
-    await this.request.post<{ result: string }>(`/config/automation/config/${encodeURIComponent(automationId)}`, {
-      id: automationId,
-      alias: config.alias,
-      description: config.description || '',
-      mode: config.mode ?? 'single',
-      trigger: config.trigger,
-      condition: config.condition || [],
-      action: config.action,
-    });
-
-    // Reload automations to pick up the new one
-    if (this.serviceOps) {
-      await this.serviceOps.callService({
-        domain: 'automation',
-        service: 'reload',
-      });
-    }
-
-    return { id: automationId };
-  }
-
-  /**
-   * Update an existing automation
-   * Note: Requires the automation's unique_id from the automation registry
-   */
-  async updateAutomation(automationId: string, config: Partial<AutomationConfig>): Promise<void> {
-    if (!this.request) {
-      throw new Error('RequestHandler not available');
-    }
-
-    logger.info('Updating automation', { automationId, alias: config.alias });
-
-    await this.request.post(`/config/automation/config/${automationId}`, config);
-  }
-
-  /**
-   * Delete an automation
-   * Note: Only works for automations created via the UI/API
-   */
-  async deleteAutomation(automationId: string): Promise<void> {
-    if (!this.request) {
-      throw new Error('RequestHandler not available');
-    }
-
-    logger.info('Deleting automation', { automationId });
-
-    await this.request.request(`/config/automation/config/${automationId}`, {
-      method: 'DELETE',
-    });
-  }
-
-  /**
-   * Get automation trace (execution history)
-   */
-  async getAutomationTrace(entityId: string, limit = 5): Promise<AutomationTraceSummary[]> {
-    if (!this.wsCommand) {
-      throw new Error('Automation traces need the Home Assistant WebSocket API, which is not available');
-    }
-
-    // Traces are WebSocket-only (there is no REST endpoint) and are keyed by the
-    // automation's config id (its `id` attribute), not by the entity id.
-    const state = await this.stateOps.getState(entityId);
-    if (!state) {
-      throw new Error(`Automation ${entityId} not found`);
-    }
-    const itemId = state.attributes.id;
-    if (itemId === undefined || itemId === null || itemId === '') {
-      throw new Error(
-        `Automation ${entityId} has no 'id' (an automation defined in YAML without an id), so Home Assistant keeps no traces for it`
-      );
-    }
-    logger.debug('Fetching automation traces', { entityId, itemId });
-
-    const traces = await this.wsCommand<AutomationTraceSummary[]>({
-      type: 'trace/list',
-      domain: 'automation',
-      item_id: String(itemId),
-    });
-    return [...(traces ?? [])]
-      .sort((a, b) => (b.timestamp?.start ?? '').localeCompare(a.timestamp?.start ?? ''))
-      .slice(0, limit);
-  }
-}

package/src/haClient/calendars.ts

@@ -1,94 +0,0 @@
-/**
- * Calendar Operations for Home Assistant API
- * Handles calendar listing and event retrieval
- */
-
-import type { CalendarEvent, Calendar } from '../types/index.js';
-import { logger } from '../utils/logger.js';
-import type { RequestHandler } from './request.js';
-
-interface CalendarApiResponse {
-  entity_id: string;
-  name?: string;
-}
-
-/**
- * Calendar-related operations for the Home Assistant API.
- */
-export class CalendarOperations {
-  constructor(private readonly request: RequestHandler) {}
-
-  /**
-   * Get all calendar entities
-   */
-  async getCalendars(): Promise<Calendar[]> {
-    logger.debug('Fetching calendars');
-
-    // Use dedicated /api/calendars endpoint instead of filtering all states
-    const response = await this.request.get<CalendarApiResponse[]>('/calendars');
-    const calendars = response.map(cal => ({
-      entity_id: cal.entity_id,
-      name: cal.name || cal.entity_id.replace('calendar.', ''),
-      state: 'on', // Calendar API doesn't return state, default to 'on'
-    }));
-
-    logger.info('Fetched calendars', { count: calendars.length });
-    return calendars;
-  }
-
-  /**
-   * Get events from a calendar
-   * @param entityId - Calendar entity ID (e.g., 'calendar.my_calendar')
-   * @param startDate - Start date for event range (defaults to now)
-   * @param endDate - End date for event range (defaults to 30 days from start)
-   */
-  async getCalendarEvents(
-    entityId: string,
-    startDate?: Date,
-    endDate?: Date
-  ): Promise<CalendarEvent[]> {
-    const start = startDate || new Date();
-    const end = endDate || new Date(start.getTime() + 30 * 24 * 60 * 60 * 1000);
-
-    logger.debug('Fetching calendar events', { entityId, start: start.toISOString(), end: end.toISOString() });
-
-    // Calendar events use a special API endpoint, not the standard services API
-    const events = await this.request.get<CalendarEvent[]>(
-      `/calendars/${encodeURIComponent(entityId)}`,
-      {
-        start: start.toISOString(),
-        end: end.toISOString(),
-      }
-    );
-
-    logger.info('Fetched calendar events', { entityId, count: events.length });
-    return events;
-  }
-
-  /**
-   * Get events from all calendars
-   * @param startDate - Start date for event range (defaults to now)
-   * @param endDate - End date for event range (defaults to 30 days from start)
-   */
-  async getAllCalendarEvents(
-    startDate?: Date,
-    endDate?: Date
-  ): Promise<Array<{ calendar: string; events: CalendarEvent[] }>> {
-    const calendars = await this.getCalendars();
-
-    // Fetch all calendar events in parallel
-    const results = await Promise.all(
-      calendars.map(async calendar => {
-        try {
-          const events = await this.getCalendarEvents(calendar.entity_id, startDate, endDate);
-          return { calendar: calendar.entity_id, events };
-        } catch (error) {
-          logger.warn('Failed to fetch events for calendar', { calendar: calendar.entity_id, error });
-          return { calendar: calendar.entity_id, events: [] };
-        }
-      })
-    );
-
-    return results;
-  }
-}

package/src/haClient/config.ts

@@ -1,52 +0,0 @@
-/**
- * Config Operations for Home Assistant API
- * Handles configuration and version information
- */
-
-import type { HaVersion } from '../types/index.js';
-import { logger } from '../utils/logger.js';
-import type { RequestHandler } from './request.js';
-
-/**
- * Config-related operations for the Home Assistant API.
- */
-export class ConfigOperations {
-  constructor(private readonly request: RequestHandler) {}
-
-  /**
-   * Get config
-   */
-  async getConfig(): Promise<Record<string, unknown>> {
-    logger.debug('Fetching config');
-    return await this.request.get<Record<string, unknown>>('/config');
-  }
-
-  /**
-   * Check API (health check)
-   */
-  async checkApi(): Promise<{ message: string }> {
-    logger.debug('Checking API health');
-    return await this.request.get<{ message: string }>('/');
-  }
-
-  /**
-   * Get Home Assistant version and configuration info
-   * Returns only safe, public information (filters out internal config details)
-   */
-  async getVersion(): Promise<HaVersion> {
-    logger.debug('Fetching Home Assistant version');
-    const config = await this.request.get<Record<string, unknown>>('/config');
-    logger.info('Fetched version', { version: config.version });
-
-    // Return only safe, public information
-    // Excludes: components, allowlist_external_dirs, allowlist_external_urls,
-    // config_dir, whitelist_external_dirs, safe_mode, state, external_url, internal_url,
-    // currency, country, language, latitude, longitude, elevation
-    return {
-      version: config.version as string,
-      location_name: config.location_name as string | undefined,
-      time_zone: config.time_zone as string | undefined,
-      unit_system: config.unit_system as Record<string, string> | undefined,
-    };
-  }
-}