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

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

@@ -51,7 +51,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);
     }
@@ -100,6 +101,12 @@ export class ApiServer {
         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/pipeline.js

@@ -11,6 +11,11 @@ export async function runPipeline(automation, event, haClient, deps) {
         timestamp,
         ...(deps.dryRun ? { dry_run: true } : {}),
     };
+    // Step 1: Enabled check
+    if (automation.enabled === false) {
+        deps.observability.publishDecision({ ...base, event_type: 'abort', reason: 'disabled' });
+        return;
+    }
     // Step 2: Context
     let ctx;
     try {

package/dist/src/framework/trigger-engine.d.ts

@@ -13,6 +13,7 @@ export declare class TriggerEngine {
     private readonly onMatch;
     private readonly mqttClient?;
     private readonly buttonHandlers;
+    private regexButtonTriggers;
     private readonly durationTimers;
     constructor(registry: AutomationRegistry, haClient: HAClient, onMatch: (automation: Automation<unknown>, event: TriggerEvent) => void, mqttClient?: MqttClient | undefined);
     private rebuildButtonHandlers;

package/dist/src/framework/trigger-engine.js

@@ -1,49 +1,72 @@
-const DOUBLE_PRESS_WINDOW_MS = 400;
+const DOUBLE_PRESS_WINDOW_MS = 250;
 class ButtonGestureHandler {
     entityId;
     dispatch;
     supportsDoublePress;
     gestureState = 'idle';
     resolveTimer = null;
+    holdFired = false;
+    // Set when 'release' fires a short press; suppresses the trailing confirmation
+    // event ('on', 'toggle', etc.) so the same physical press doesn't fire twice.
+    shortFired = false;
     constructor(entityId, dispatch, supportsDoublePress) {
         this.entityId = entityId;
         this.dispatch = dispatch;
         this.supportsDoublePress = supportsDoublePress;
     }
     handle(actionState, correlationId) {
+        if (actionState === '')
+            return;
         const parsed = parseButtonAction(actionState);
         if (!parsed)
             return;
         const { button, pressType } = parsed;
+        const isRelease = actionState.toLowerCase() === 'release';
+        if (pressType === 'hold') {
+            // Cancel any pending double-press window and fire hold exactly once per physical hold.
+            if (this.resolveTimer) {
+                clearTimeout(this.resolveTimer);
+                this.resolveTimer = null;
+                this.gestureState = 'idle';
+            }
+            if (!this.holdFired) {
+                this.holdFired = true;
+                this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'hold', button, correlation_id: correlationId });
+            }
+            return;
+        }
+        // pressType === 'short'
+        if (isRelease && this.holdFired) {
+            // Physical release after a hold — reset hold state, don't fire short press.
+            this.holdFired = false;
+            return;
+        }
+        if (!isRelease && this.shortFired) {
+            // Confirmation event ('on', 'toggle', etc.) after 'release' already fired — suppress.
+            this.shortFired = false;
+            return;
+        }
+        if (isRelease)
+            this.shortFired = true;
         if (this.gestureState === 'idle') {
-            if (pressType === 'short') {
-                if (!this.supportsDoublePress) {
-                    this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'single_press', button, correlation_id: correlationId });
-                }
-                else {
-                    this.gestureState = 'resolving';
-                    this.resolveTimer = setTimeout(() => {
-                        this.resolveTimer = null;
-                        this.gestureState = 'idle';
-                        this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'single_press', button, correlation_id: correlationId });
-                    }, DOUBLE_PRESS_WINDOW_MS);
-                }
+            if (!this.supportsDoublePress) {
+                this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'single_press', button, correlation_id: correlationId });
             }
             else {
-                this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'hold', button, correlation_id: correlationId });
+                this.gestureState = 'resolving';
+                this.resolveTimer = setTimeout(() => {
+                    this.resolveTimer = null;
+                    this.gestureState = 'idle';
+                    this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'single_press', button, correlation_id: correlationId });
+                }, DOUBLE_PRESS_WINDOW_MS);
             }
         }
         else {
-            // resolving — waiting for double press
+            // resolving — second short press = double press
             clearTimeout(this.resolveTimer);
             this.resolveTimer = null;
             this.gestureState = 'idle';
-            if (pressType === 'short') {
-                this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'double_press', button, correlation_id: correlationId });
-            }
-            else {
-                this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'hold', button, correlation_id: correlationId });
-            }
+            this.dispatch({ type: 'button', entity_id: this.entityId, gesture: 'double_press', button, correlation_id: correlationId });
         }
     }
 }
@@ -57,7 +80,7 @@ export function parseButtonAction(state) {
     const action = prefixed ? prefixed[2] : s;
     if (/long|hold/.test(action))
         return { button, pressType: 'hold' };
-    if (/short|click|single/.test(action) || action === 'press' || action === 'on' || action === 'toggle') {
+    if (/short|click|single/.test(action) || action === 'on' || action === 'toggle' || action === 'release') {
         return { button, pressType: 'short' };
     }
     return null;
@@ -69,6 +92,7 @@ export class TriggerEngine {
     onMatch;
     mqttClient;
     buttonHandlers = new Map();
+    regexButtonTriggers = [];
     durationTimers = new Map();
     constructor(registry, haClient, onMatch, mqttClient) {
         this.registry = registry;
@@ -80,26 +104,50 @@ export class TriggerEngine {
     }
     rebuildButtonHandlers() {
         this.buttonHandlers.clear();
+        this.regexButtonTriggers = [];
         const entityGestures = new Map();
+        const regexGestures = new Map();
         for (const automation of this.registry.getAll()) {
             for (const trigger of automation.triggers) {
                 if (trigger.type === 'button') {
-                    if (!entityGestures.has(trigger.entity)) {
-                        entityGestures.set(trigger.entity, new Set());
+                    if (typeof trigger.entity === 'string') {
+                        if (!entityGestures.has(trigger.entity))
+                            entityGestures.set(trigger.entity, new Set());
+                        entityGestures.get(trigger.entity).add(trigger.gesture);
+                    }
+                    else {
+                        if (!regexGestures.has(trigger.entity))
+                            regexGestures.set(trigger.entity, new Set());
+                        regexGestures.get(trigger.entity).add(trigger.gesture);
                     }
-                    entityGestures.get(trigger.entity).add(trigger.gesture);
                 }
             }
         }
         for (const [entity, gestures] of entityGestures) {
             this.buttonHandlers.set(entity, new ButtonGestureHandler(entity, (e) => this.dispatch(e), gestures.has('double_press')));
         }
+        for (const [pattern, gestures] of regexGestures) {
+            this.regexButtonTriggers.push({ pattern, gestures });
+        }
     }
     start() {
         this.haClient.ready
             .then(() => {
             this.haClient.on('state_changed', (event) => {
-                const handler = this.buttonHandlers.get(event.entity_id);
+                let handler = this.buttonHandlers.get(event.entity_id);
+                if (!handler) {
+                    const matchingGestures = new Set();
+                    for (const { pattern, gestures } of this.regexButtonTriggers) {
+                        if (pattern.test(event.entity_id)) {
+                            for (const g of gestures)
+                                matchingGestures.add(g);
+                        }
+                    }
+                    if (matchingGestures.size > 0) {
+                        handler = new ButtonGestureHandler(event.entity_id, (e) => this.dispatch(e), matchingGestures.has('double_press'));
+                        this.buttonHandlers.set(event.entity_id, handler);
+                    }
+                }
                 if (handler) {
                     handler.handle(event.new_state.state, event.correlation_id);
                 }
@@ -200,7 +248,10 @@ function matchesTrigger(trigger, event) {
         case 'button': {
             if (event.type !== 'button')
                 return false;
-            return (trigger.entity === event.entity_id &&
+            const entityMatch = typeof trigger.entity === 'string'
+                ? trigger.entity === event.entity_id
+                : trigger.entity.test(event.entity_id);
+            return (entityMatch &&
                 trigger.gesture === event.gesture &&
                 (trigger.button === undefined || trigger.button === event.button));
         }

package/dist/src/testing.d.ts

@@ -4,6 +4,8 @@ import type { HAContext } from './framework/ha-client.js';
 type TestStateEntry = {
     state: string;
     attributes?: Record<string, unknown>;
+    last_changed?: string;
+    last_updated?: string;
 };
 interface TestOptions {
     event: TriggerEvent;

package/dist/src/testing.js

@@ -9,8 +9,8 @@ export function testAutomation(automation, options) {
             entity_id: entityId,
             state: entry.state,
             attributes: entry.attributes ?? {},
-            last_changed: '',
-            last_updated: '',
+            last_changed: entry.last_changed ?? '',
+            last_updated: entry.last_updated ?? '',
         };
     };
     const haContext = {

package/dist/src/types/automation.d.ts

@@ -18,6 +18,7 @@ export interface Automation<C> {
     id: string;
     location: string;
     subsystem: string;
+    enabled?: boolean;
     triggers: Trigger[];
     context: (state: HAState, ha: HAContext, event: TriggerEvent) => C | Abort;
     reduce: (ctx: C) => Decision;

package/dist/src/types/triggers.d.ts

@@ -13,7 +13,7 @@ export type Trigger = {
     timerKey: string;
 } | {
     type: 'button';
-    entity: string;
+    entity: string | RegExp;
     gesture: 'single_press' | 'double_press' | 'hold';
     button?: string;
 } | {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ajclarkson/homerun",
   "type": "module",
-  "version": "0.0.1-edge.db0717b",
+  "version": "0.0.1-edge.efd408a",
   "description": "TypeScript automation framework for Home Assistant",
   "files": [
     "dist"