@ajclarkson/homerun 0.0.1-edge.db0717b → 0.0.1-edge.e40faa4

package/dist/scripts/generate-ha-services.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+export interface HAServicePayload {
+    domain: string;
+    services: Record<string, HAServiceDef>;
+}
+export interface HAServiceDef {
+    fields: Record<string, HAServiceField>;
+    target?: unknown;
+}
+export interface HAServiceField {
+    required?: boolean;
+    selector?: Record<string, unknown>;
+    advanced?: boolean;
+}
+export declare function inferFieldType(field: HAServiceField): string;
+export declare function generateFileContent(services: HAServicePayload[], domains?: string[]): string;

package/dist/scripts/generate-ha-services.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+// ---------- Type inference ----------
+export function inferFieldType(field) {
+    const selector = field.selector;
+    if (!selector)
+        return 'unknown';
+    const key = Object.keys(selector)[0];
+    if (!key)
+        return 'unknown';
+    switch (key) {
+        case 'number':
+        case 'color_temp':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'color_rgb':
+            return '[number, number, number]';
+        case 'duration':
+            return '{ hours?: number; minutes?: number; seconds?: number }';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            return 'string';
+    }
+}
+// ---------- Service builder generation ----------
+function generateServiceBuilder(domain, service, def) {
+    const hasTarget = !!def.target;
+    const fieldEntries = Object.entries(def.fields ?? {});
+    const hasFields = fieldEntries.length > 0;
+    const params = [];
+    if (hasTarget)
+        params.push('target: { entity_id: string }');
+    let anyRequired = false;
+    if (hasFields) {
+        anyRequired = fieldEntries.some(([, f]) => f.required);
+        const fieldDefs = fieldEntries
+            .map(([name, field]) => `${name}${field.required ? '' : '?'}: ${inferFieldType(field)}`)
+            .join('; ');
+        params.push(`data${anyRequired ? '' : '?'}: { ${fieldDefs} }`);
+    }
+    const bodyParts = [
+        `type: 'ha.call_service'`,
+        `domain: '${domain}'`,
+        `service: '${service}'`,
+    ];
+    if (hasTarget)
+        bodyParts.push('target');
+    if (hasFields) {
+        bodyParts.push(`data: data as Record<string, unknown>${anyRequired ? '' : ' | undefined'}`);
+    }
+    return `    ${service}: (${params.join(', ')}): Action => ({ ${bodyParts.join(', ')} })`;
+}
+// ---------- File generation ----------
+export function generateFileContent(services, domains) {
+    const filtered = domains
+        ? services.filter(({ domain }) => domains.includes(domain))
+        : services;
+    const domainBlocks = filtered.map(({ domain, services: svcMap }) => {
+        const builders = Object.entries(svcMap)
+            .map(([service, def]) => generateServiceBuilder(domain, service, def))
+            .join(',\n');
+        return `  ${domain}: {\n${builders},\n  }`;
+    });
+    const domainsNote = domains ? `\n// domains: ${domains.join(', ')}` : '';
+    const blockStr = domainBlocks.length > 0 ? `\n${domainBlocks.join(',\n')},\n` : '';
+    return `// generated — do not edit — run: npm run generate:ha-services${domainsNote}
+import type { Action } from '@ajclarkson/homerun';
+
+export const Services = {${blockStr}};
+`;
+}
+// ---------- CLI ----------
+async function main() {
+    const url = process.env.HA_URL;
+    const token = process.env.HA_TOKEN;
+    if (!url || !token) {
+        console.error('Error: HA_URL and HA_TOKEN must be set');
+        process.exit(1);
+    }
+    const domainsArg = process.argv.find((a) => a.startsWith('--domains='));
+    const domains = domainsArg ? domainsArg.slice('--domains='.length).split(',') : undefined;
+    const res = await fetch(`${url}/api/services`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        console.error(`Error: HA API returned ${res.status} ${res.statusText}`);
+        process.exit(1);
+    }
+    const allServices = (await res.json());
+    const content = generateFileContent(allServices, domains);
+    const outPath = path.join(process.cwd(), 'types', 'ha-services.ts');
+    await mkdir(path.dirname(outPath), { recursive: true });
+    await writeFile(outPath, content, 'utf8');
+    const filtered = domains
+        ? allServices.filter(({ domain }) => domains.includes(domain))
+        : allServices;
+    const serviceCount = filtered.reduce((n, { services: s }) => n + Object.keys(s).length, 0);
+    const domainLabel = domains ? `${domains.length} selected` : `all ${allServices.length}`;
+    console.log(`Written ${serviceCount} services across ${domainLabel} domains to ${outPath}`);
+}
+if (process.argv[1]?.endsWith('generate-ha-services.ts') ||
+    process.argv[1]?.endsWith('generate-ha-services.js') ||
+    process.argv[1]?.endsWith('homerun-generate-ha-services')) {
+    main().catch((err) => {
+        console.error('Fatal:', err);
+        process.exit(1);
+    });
+}

package/dist/src/framework/action-runtime.d.ts

@@ -2,7 +2,8 @@ import type { MqttClient } from 'mqtt';
 import type { Action } from '../types/actions.js';
 import type { HAClient } from './ha-client.js';
 import type { TimerManager } from './timer-manager.js';
-import type { Observability } from './observability.js';
+import type { EventPublisher } from './event-publisher.js';
+import type { MetricsBackend } from './metrics.js';
 export interface ExecutionContext {
     correlationId: string;
     automationId: string;
@@ -13,8 +14,9 @@ interface Deps {
     haClient: HAClient;
     mqttClient: MqttClient;
     timerManager: TimerManager;
-    observability: Observability;
+    eventPublisher: EventPublisher;
     dryRun: boolean;
+    metrics?: MetricsBackend;
 }
 export declare class ActionRuntime {
     private readonly deps;

package/dist/src/framework/action-runtime.js

@@ -9,16 +9,25 @@ export class ActionRuntime {
         }
     }
     async runAction(action, ctx) {
-        this.deps.observability.publishActionEvent(this.makeEvent(ctx, 'action_started', action));
+        const labels = { location: ctx.location, action_type: action.type };
+        this.deps.eventPublisher.publishActionEvent(this.makeEvent(ctx, 'action_started', action));
+        this.deps.metrics?.incrementCounter('homerun_actions_dispatched_total', labels);
+        const start = performance.now();
         try {
             if (!this.deps.dryRun) {
                 await this.dispatch(action);
             }
-            this.deps.observability.publishActionEvent(this.makeEvent(ctx, 'action_result', action, { reason: 'ok' }));
+            const duration = (performance.now() - start) / 1000;
+            this.deps.metrics?.observeHistogram('homerun_action_duration_seconds', duration, labels);
+            this.deps.metrics?.incrementCounter('homerun_actions_succeeded_total', labels);
+            this.deps.eventPublisher.publishActionEvent(this.makeEvent(ctx, 'action_result', action, { reason: 'ok' }));
         }
         catch (err) {
+            const duration = (performance.now() - start) / 1000;
+            this.deps.metrics?.observeHistogram('homerun_action_duration_seconds', duration, labels);
+            this.deps.metrics?.incrementCounter('homerun_actions_failed_total', labels);
             const reason = err instanceof Error ? err.message : String(err);
-            this.deps.observability.publishActionEvent(this.makeEvent(ctx, 'action_result', action, { reason }));
+            this.deps.eventPublisher.publishActionEvent(this.makeEvent(ctx, 'action_result', action, { reason }));
         }
     }
     async dispatch(action) {

package/dist/src/framework/api-server.d.ts

@@ -1,15 +1,20 @@
 import type { AutomationRegistry } from './registry.js';
-import type { Observability } from './observability.js';
+import type { EventPublisher } from './event-publisher.js';
 import type { Automation } from '../types/automation.js';
 import type { TriggerEvent } from '../types/triggers.js';
+export interface MetricsProvider {
+    getMetrics(): Promise<string>;
+    contentType: string;
+}
 export interface ApiServerDeps {
     registry: AutomationRegistry;
     onTrigger: (automation: Automation<unknown>, event: TriggerEvent) => void;
     onReload: () => Promise<void>;
     isReady: () => boolean;
     entityCount: () => number;
-    observability: Observability;
+    eventPublisher: EventPublisher;
     dryRun?: boolean;
+    metrics?: MetricsProvider;
 }
 export declare class ApiServer {
     private readonly deps;
@@ -25,5 +30,6 @@ export declare class ApiServer {
     private postReload;
     private getHealthLive;
     private getHealthReady;
+    private getMetrics;
     private getEvents;
 }

package/dist/src/framework/api-server.js

@@ -41,6 +41,8 @@ export class ApiServer {
             return this.getHealthReady(res);
         if (method === 'GET' && url === '/events')
             return this.getEvents(req, res);
+        if (method === 'GET' && url === '/metrics')
+            return this.getMetrics(res);
         const triggerMatch = method === 'POST' && url.match(/^\/automations\/(.+)\/trigger$/);
         if (triggerMatch)
             return this.postTrigger(triggerMatch[1], res);
@@ -51,7 +53,8 @@ export class ApiServer {
             id: a.id,
             location: a.location,
             subsystem: a.subsystem,
-            triggerTypes: a.triggers.map((t) => t.type),
+            enabled: a.enabled ?? true,
+            triggers: a.triggers.map(serializeTrigger),
         }));
         json(res, 200, automations);
     }
@@ -87,6 +90,21 @@ export class ApiServer {
             ...(this.deps.dryRun && { dry_run: true }),
         });
     }
+    getMetrics(res) {
+        if (!this.deps.metrics) {
+            json(res, 404, { error: 'metrics not enabled' });
+            return;
+        }
+        this.deps.metrics.getMetrics()
+            .then((output) => {
+            res.writeHead(200, { 'Content-Type': this.deps.metrics.contentType });
+            res.end(output);
+        })
+            .catch((err) => {
+            console.error('[ApiServer] metrics scrape failed:', err);
+            json(res, 500, { error: 'metrics scrape failed' });
+        });
+    }
     getEvents(req, res) {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -94,12 +112,18 @@ export class ApiServer {
             Connection: 'keep-alive',
         });
         res.flushHeaders();
-        const unsubscribe = this.deps.observability.subscribe((event) => {
+        const unsubscribe = this.deps.eventPublisher.subscribe((event) => {
             res.write(`data: ${JSON.stringify(event)}\n\n`);
         });
         req.on('close', unsubscribe);
     }
 }
+function serializeTrigger(trigger) {
+    if (trigger.type === 'state_changed' && trigger.entity instanceof RegExp) {
+        return { ...trigger, entity: trigger.entity.toString() };
+    }
+    return trigger;
+}
 function json(res, status, body) {
     const payload = JSON.stringify(body);
     res.writeHead(status, { 'Content-Type': 'application/json' });

package/dist/src/framework/config.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+declare const ConfigSchema: z.ZodObject<{
+    homeassistant: z.ZodObject<{
+        url: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strip>;
+    mqtt: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>;
+    automations: z.ZodObject<{
+        dir: z.ZodString;
+    }, z.core.$strip>;
+    server: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        shutdown_timeout_ms: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+    options: z.ZodDefault<z.ZodObject<{
+        dry_run: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    metrics: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HomerunConfig = z.infer<typeof ConfigSchema>;
+export declare function parseConfig(configContent: string, secretsContent?: string): HomerunConfig;
+export declare function loadConfig(configPath?: string): Promise<HomerunConfig>;
+export {};

package/dist/src/framework/config.js

@@ -0,0 +1,80 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { load, CORE_SCHEMA, defineScalarTag } from 'js-yaml';
+import { z } from 'zod';
+function isSecretRef(v) {
+    return typeof v === 'object' && v !== null && '__secret' in v;
+}
+const secretTag = defineScalarTag('!secret', {
+    implicit: false,
+    resolve: (source) => ({ __secret: source }),
+});
+const SCHEMA_WITH_SECRET = CORE_SCHEMA.withTags(secretTag);
+const ConfigSchema = z.object({
+    homeassistant: z.object({
+        url: z.string().min(1, 'homeassistant.url is required'),
+        token: z.string().min(1, 'homeassistant.token is required'),
+    }),
+    mqtt: z.object({
+        url: z.string().min(1, 'mqtt.url is required'),
+    }),
+    automations: z.object({
+        dir: z.string().min(1, 'automations.dir is required'),
+    }),
+    server: z.object({
+        port: z.coerce.number().int().min(1).max(65535).default(7070),
+        shutdown_timeout_ms: z.coerce.number().int().min(0).default(10_000),
+    }).default({ port: 7070, shutdown_timeout_ms: 10_000 }),
+    options: z.object({
+        dry_run: z.boolean().default(false),
+    }).default({ dry_run: false }),
+    metrics: z.object({
+        enabled: z.boolean().default(false),
+    }).default({ enabled: false }),
+});
+function resolveSecrets(value, secrets) {
+    if (isSecretRef(value)) {
+        const key = value.__secret;
+        if (!(key in secrets)) {
+            throw new Error(`!secret '${key}' not found in secrets.yaml`);
+        }
+        return secrets[key];
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveSecrets(item, secrets));
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveSecrets(v, secrets)]));
+    }
+    return value;
+}
+export function parseConfig(configContent, secretsContent) {
+    const raw = (load(configContent, { schema: SCHEMA_WITH_SECRET }) ?? {});
+    const secrets = secretsContent
+        ? (load(secretsContent) ?? {})
+        : {};
+    const resolved = resolveSecrets(raw, secrets);
+    const result = ConfigSchema.safeParse(resolved);
+    if (!result.success) {
+        const errors = result.error.issues
+            .map((i) => `  ${i.path.join('.') || '(root)'}: ${i.message}`)
+            .join('\n');
+        throw new Error(`[homerun] Invalid configuration:\n${errors}`);
+    }
+    return result.data;
+}
+export async function loadConfig(configPath) {
+    const absPath = path.resolve(configPath ?? process.env.HOMERUN_CONFIG ?? './configuration.yaml');
+    if (!existsSync(absPath)) {
+        throw new Error(`[homerun] Config file not found: ${absPath}\n` +
+            'Create configuration.yaml or set HOMERUN_CONFIG to point to your config file.\n' +
+            'See configuration.yaml.example for reference.');
+    }
+    const configContent = await readFile(absPath, 'utf8');
+    const secretsPath = path.join(path.dirname(absPath), 'secrets.yaml');
+    const secretsContent = existsSync(secretsPath)
+        ? await readFile(secretsPath, 'utf8')
+        : undefined;
+    return parseConfig(configContent, secretsContent);
+}

package/dist/src/framework/{observability.d.ts → event-publisher.d.ts}

@@ -14,7 +14,7 @@ export interface ObsEvent {
     dry_run?: boolean;
     timestamp: string;
 }
-export type LifecycleEventType = 'server_started' | 'rescan_complete' | 'ha_reconnected';
+export type LifecycleEventType = 'server_started' | 'server_stopping' | 'rescan_complete' | 'ha_reconnected';
 export interface LifecycleEvent {
     schema: 'home.lifecycle.v1';
     type: LifecycleEventType;
@@ -22,7 +22,7 @@ export interface LifecycleEvent {
     timestamp: string;
     dry_run?: boolean;
 }
-export declare class Observability {
+export declare class EventPublisher {
     private readonly mqtt;
     private readonly listeners;
     constructor(mqtt: MqttClient);

package/dist/src/framework/{observability.js → event-publisher.js}

@@ -1,4 +1,4 @@
-export class Observability {
+export class EventPublisher {
     mqtt;
     listeners = [];
     constructor(mqtt) {
@@ -41,7 +41,7 @@ export class Observability {
     }
     publish(topic, payload, retain) {
         this.mqtt.publishAsync(topic, payload, { retain }).catch((err) => {
-            console.error(`[Observability] MQTT publish failed on ${topic}:`, err);
+            console.error(`[EventPublisher] MQTT publish failed on ${topic}:`, err);
         });
     }
 }

package/dist/src/framework/ha-client.d.ts

@@ -40,6 +40,7 @@ export declare class HAClient extends EventEmitter {
     readonly context: HAContext;
     get entityCount(): number;
     callService(domain: string, service: string, target?: HassServiceTarget, data?: Record<string, unknown>): Promise<void>;
+    disconnect(): void;
     connect(url: string, token: string): Promise<void>;
     private repopulateCache;
     private diffAndUpdate;

package/dist/src/framework/ha-client.js

@@ -28,6 +28,10 @@ export class HAClient extends EventEmitter {
             throw new Error('HAClient not connected');
         await callService(this.connection, domain, service, data, target);
     }
+    disconnect() {
+        this.connection?.close();
+        this.connection = null;
+    }
     async connect(url, token) {
         const auth = createLongLivedTokenAuth(url, token);
         this.connection = await createConnection({ auth });

package/dist/src/framework/hot-reload.js

@@ -45,11 +45,12 @@ export function _deleteFile(filePath, registry, fileToIds = moduleFileToIds) {
     }
     fileToIds.delete(filePath);
 }
+const EXCLUDED_DIRS = new Set(['types', 'lib']);
 const isAutomationFile = (f) => f.endsWith('.ts') &&
     !f.endsWith('.test.ts') &&
     !f.includes('node_modules') &&
     !f.includes('.d.ts') &&
-    !f.split(path.sep).includes('types');
+    !f.split(path.sep).some(seg => EXCLUDED_DIRS.has(seg));
 export async function rescanAutomations(automationsDir, registry, fileToIds = moduleFileToIds, importer = defaultImporter) {
     let files = [];
     try {

package/dist/src/framework/metrics-prom.d.ts

@@ -0,0 +1,18 @@
+import { Registry } from 'prom-client';
+import type { MetricsBackend } from './metrics.js';
+export declare class PromMetricsBackend implements MetricsBackend {
+    readonly registry: Registry<"text/plain; version=0.0.4; charset=utf-8">;
+    private readonly haEventsTotal;
+    private readonly pipelineRunsTotal;
+    private readonly actionsDispatchedTotal;
+    private readonly actionsSucceededTotal;
+    private readonly actionsFailedTotal;
+    private readonly actionDurationSeconds;
+    private readonly automationsLoaded;
+    constructor(collectDefaults?: boolean);
+    incrementCounter(name: string, labels?: Record<string, string>): void;
+    observeHistogram(name: string, value: number, labels?: Record<string, string>): void;
+    setGauge(name: string, value: number): void;
+    getMetrics(): Promise<string>;
+    get contentType(): string;
+}

package/dist/src/framework/metrics-prom.js

@@ -0,0 +1,93 @@
+import { Registry, Counter, Gauge, Histogram, collectDefaultMetrics } from 'prom-client';
+export class PromMetricsBackend {
+    registry = new Registry();
+    haEventsTotal;
+    pipelineRunsTotal;
+    actionsDispatchedTotal;
+    actionsSucceededTotal;
+    actionsFailedTotal;
+    actionDurationSeconds;
+    automationsLoaded;
+    constructor(collectDefaults = false) {
+        if (collectDefaults) {
+            collectDefaultMetrics({ register: this.registry });
+        }
+        this.haEventsTotal = new Counter({
+            name: 'homerun_ha_events_received_total',
+            help: 'Total HA and MQTT events received by homerun',
+            labelNames: ['event_type'],
+            registers: [this.registry],
+        });
+        this.pipelineRunsTotal = new Counter({
+            name: 'homerun_pipeline_runs_total',
+            help: 'Total automation pipeline runs',
+            labelNames: ['location', 'trigger_type'],
+            registers: [this.registry],
+        });
+        this.actionsDispatchedTotal = new Counter({
+            name: 'homerun_actions_dispatched_total',
+            help: 'Total actions dispatched by the action runtime',
+            labelNames: ['location', 'action_type'],
+            registers: [this.registry],
+        });
+        this.actionsSucceededTotal = new Counter({
+            name: 'homerun_actions_succeeded_total',
+            help: 'Total actions that completed successfully',
+            labelNames: ['location', 'action_type'],
+            registers: [this.registry],
+        });
+        this.actionsFailedTotal = new Counter({
+            name: 'homerun_actions_failed_total',
+            help: 'Total actions that failed with an error',
+            labelNames: ['location', 'action_type'],
+            registers: [this.registry],
+        });
+        this.actionDurationSeconds = new Histogram({
+            name: 'homerun_action_duration_seconds',
+            help: 'Duration of action execution in seconds',
+            labelNames: ['location', 'action_type'],
+            buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
+            registers: [this.registry],
+        });
+        this.automationsLoaded = new Gauge({
+            name: 'homerun_automations_loaded',
+            help: 'Number of automations currently loaded',
+            registers: [this.registry],
+        });
+    }
+    incrementCounter(name, labels = {}) {
+        switch (name) {
+            case 'homerun_ha_events_received_total':
+                this.haEventsTotal.inc(labels);
+                break;
+            case 'homerun_pipeline_runs_total':
+                this.pipelineRunsTotal.inc(labels);
+                break;
+            case 'homerun_actions_dispatched_total':
+                this.actionsDispatchedTotal.inc(labels);
+                break;
+            case 'homerun_actions_succeeded_total':
+                this.actionsSucceededTotal.inc(labels);
+                break;
+            case 'homerun_actions_failed_total':
+                this.actionsFailedTotal.inc(labels);
+                break;
+        }
+    }
+    observeHistogram(name, value, labels = {}) {
+        if (name === 'homerun_action_duration_seconds') {
+            this.actionDurationSeconds.observe(labels, value);
+        }
+    }
+    setGauge(name, value) {
+        if (name === 'homerun_automations_loaded') {
+            this.automationsLoaded.set(value);
+        }
+    }
+    async getMetrics() {
+        return this.registry.metrics();
+    }
+    get contentType() {
+        return this.registry.contentType;
+    }
+}

package/dist/src/framework/metrics.d.ts

@@ -0,0 +1,10 @@
+export interface MetricsBackend {
+    incrementCounter(name: string, labels?: Record<string, string>): void;
+    observeHistogram(name: string, value: number, labels?: Record<string, string>): void;
+    setGauge(name: string, value: number, labels?: Record<string, string>): void;
+}
+export declare class NoopMetricsBackend implements MetricsBackend {
+    incrementCounter(): void;
+    observeHistogram(): void;
+    setGauge(): void;
+}

package/dist/src/framework/metrics.js

@@ -0,0 +1,5 @@
+export class NoopMetricsBackend {
+    incrementCounter() { }
+    observeHistogram() { }
+    setGauge() { }
+}

package/dist/src/framework/pipeline.d.ts

@@ -1,12 +1,14 @@
 import type { Automation } from '../types/automation.js';
 import type { TriggerEvent } from '../types/triggers.js';
 import type { HAClient } from './ha-client.js';
-import type { Observability } from './observability.js';
+import type { EventPublisher } from './event-publisher.js';
 import type { ActionRuntime } from './action-runtime.js';
+import type { MetricsBackend } from './metrics.js';
 interface Deps {
-    observability: Observability;
+    eventPublisher: EventPublisher;
     actionRuntime: ActionRuntime;
     dryRun?: boolean;
+    metrics?: MetricsBackend;
 }
 export declare function runPipeline(automation: Automation<unknown>, event: TriggerEvent, haClient: HAClient, deps: Deps): Promise<void>;
 export {};

package/dist/src/framework/pipeline.js

@@ -1,5 +1,9 @@
 import { isAbort } from '../types/automation.js';
 export async function runPipeline(automation, event, haClient, deps) {
+    deps.metrics?.incrementCounter('homerun_pipeline_runs_total', {
+        location: automation.location,
+        trigger_type: event.type,
+    });
     const correlationId = event.correlation_id;
     const timestamp = new Date().toISOString();
     const base = {
@@ -11,17 +15,22 @@ export async function runPipeline(automation, event, haClient, deps) {
         timestamp,
         ...(deps.dryRun ? { dry_run: true } : {}),
     };
+    // Step 1: Enabled check
+    if (automation.enabled === false) {
+        deps.eventPublisher.publishDecision({ ...base, event_type: 'abort', reason: 'disabled' });
+        return;
+    }
     // Step 2: Context
     let ctx;
     try {
         ctx = automation.context(haClient.state, haClient.context, event);
     }
     catch {
-        deps.observability.publishDecision({ ...base, event_type: 'abort', reason: 'unhandled_error' });
+        deps.eventPublisher.publishDecision({ ...base, event_type: 'abort', reason: 'unhandled_error' });
         return;
     }
     if (isAbort(ctx)) {
-        deps.observability.publishDecision({ ...base, event_type: 'abort', reason: ctx.reason });
+        deps.eventPublisher.publishDecision({ ...base, event_type: 'abort', reason: ctx.reason });
         return;
     }
     // Step 3: Reduce
@@ -30,7 +39,7 @@ export async function runPipeline(automation, event, haClient, deps) {
         result = automation.reduce(ctx);
     }
     catch {
-        deps.observability.publishDecision({ ...base, event_type: 'abort', reason: 'unhandled_error' });
+        deps.eventPublisher.publishDecision({ ...base, event_type: 'abort', reason: 'unhandled_error' });
         return;
     }
     // Step 4: Validate — safe defaults
@@ -45,7 +54,7 @@ export async function runPipeline(automation, event, haClient, deps) {
     };
     // Step 5: Fanout
     await Promise.all([
-        Promise.resolve(deps.observability.publishDecision(decision)),
+        Promise.resolve(deps.eventPublisher.publishDecision(decision)),
         deps.actionRuntime.execute(actions, {
             correlationId,
             automationId: automation.id,

package/dist/src/framework/timer-manager.d.ts

@@ -5,4 +5,5 @@ export declare class TimerManager {
     constructor(dispatch: (event: TriggerEvent) => void);
     start(timerKey: string, delayMs: number): void;
     cancel(timerKey: string): void;
+    cancelAll(): void;
 }