mirror of
https://github.com/legop3/MultiRoombaRover.git
synced 2026-09-16 01:21:20 -04:00
394 lines
14 KiB
JavaScript
394 lines
14 KiB
JavaScript
// Home Assistant Runtime Engine
|
|
// Purpose: Implements entity/trigger processing, light automation policy, and exposed control operations.
|
|
// Scope: Owns business logic while transport and event wiring are delegated to companion modules.
|
|
const roverManager = require('../roverManager');
|
|
const { issueCommand } = require('../commandService');
|
|
const { publishEvent } = require('../eventBus');
|
|
const { getMode } = require('../modeManager');
|
|
const { getActiveDrivers } = require('../turnService');
|
|
const {
|
|
events,
|
|
entityConfig,
|
|
entityState,
|
|
triggerConfig,
|
|
triggerRuntime,
|
|
HA_BUTTON_EVENT_TYPE,
|
|
LIGHT_IDLE_OFF_MS,
|
|
DEFAULT_WHITE_KELVIN,
|
|
NIGHT_VISION_DISABLE_ACTION,
|
|
runtime,
|
|
} = require('./state');
|
|
const { normalizeConfigEntry, normalizeTriggerEntry, buildState } = require('./entityHelpers');
|
|
|
|
function createRuntimeEngine(deps) {
|
|
const { logger, enabled, haConfig, callHomeAssistantService } = deps;
|
|
|
|
function emitUpdate(getState) {
|
|
events.emit('update', getState());
|
|
}
|
|
|
|
function emitStatus(getState) {
|
|
events.emit('status', getState());
|
|
}
|
|
|
|
function loadEntityConfig() {
|
|
entityConfig.clear();
|
|
const list = Array.isArray(haConfig?.entities) ? haConfig.entities : [];
|
|
list.forEach((entry) => {
|
|
const normalized = normalizeConfigEntry(entry);
|
|
if (normalized) {
|
|
entityConfig.set(normalized.id, normalized);
|
|
if (!entityState.has(normalized.id)) {
|
|
entityState.set(normalized.id, buildState(normalized, null));
|
|
}
|
|
}
|
|
});
|
|
logger.info('Loaded Home Assistant entities', { count: entityConfig.size });
|
|
}
|
|
|
|
function loadTriggerConfig() {
|
|
triggerConfig.length = 0;
|
|
const list = Array.isArray(haConfig?.buttons) ? haConfig.buttons : [];
|
|
list.forEach((entry, index) => {
|
|
const normalized = normalizeTriggerEntry(entry, index);
|
|
if (!normalized) return;
|
|
triggerConfig.push(normalized);
|
|
if (!triggerRuntime.has(normalized.runtimeKey)) {
|
|
triggerRuntime.set(normalized.runtimeKey, {
|
|
lastFiredAt: 0,
|
|
lastState: null,
|
|
lastChanged: null,
|
|
lastUpdated: null,
|
|
});
|
|
}
|
|
});
|
|
logger.info('Loaded Home Assistant buttons', { count: triggerConfig.length });
|
|
}
|
|
|
|
function getControllableEntityIds() {
|
|
return Array.from(entityConfig.values()).map((meta) => String(meta.id));
|
|
}
|
|
|
|
function getActiveDriverCount() {
|
|
const active = getActiveDrivers();
|
|
const turnCount = active && typeof active === 'object' ? Object.keys(active).length : 0;
|
|
if (turnCount > 0) return turnCount;
|
|
let liveCount = 0;
|
|
roverManager.rovers.forEach((record) => {
|
|
if (record?.drivers?.size > 0) {
|
|
liveCount += 1;
|
|
}
|
|
});
|
|
return liveCount;
|
|
}
|
|
|
|
function hasActiveDrivers() {
|
|
return getActiveDriverCount() > 0;
|
|
}
|
|
|
|
function turnOffAllRoverNightVision() {
|
|
const records = Array.from(roverManager.rovers.values());
|
|
let attempted = 0;
|
|
let failed = 0;
|
|
const roverIds = [];
|
|
records.forEach((record) => {
|
|
if (!record?.ws) return;
|
|
roverIds.push(String(record.id));
|
|
attempted += 1;
|
|
try {
|
|
issueCommand(record.id, {
|
|
type: 'nightVision',
|
|
nightVision: { action: NIGHT_VISION_DISABLE_ACTION },
|
|
});
|
|
} catch (err) {
|
|
failed += 1;
|
|
logger.warn('Failed to auto turn off rover night vision after idle', { roverId: record.id, error: err.message });
|
|
}
|
|
});
|
|
return { attempted, failed, roverIds };
|
|
}
|
|
|
|
function clearLightsIdleOffTimer(getState) {
|
|
if (runtime.lightsIdleOffTimer) {
|
|
clearTimeout(runtime.lightsIdleOffTimer);
|
|
runtime.lightsIdleOffTimer = null;
|
|
}
|
|
if (runtime.lightsIdleOffDeadline != null) {
|
|
runtime.lightsIdleOffDeadline = null;
|
|
emitUpdate(getState);
|
|
}
|
|
}
|
|
|
|
async function setEntityState(entityId, desiredState) {
|
|
if (!enabled) throw new Error('Home Assistant not configured');
|
|
const meta = entityConfig.get(entityId);
|
|
if (!meta) throw new Error('Unknown Home Assistant entity');
|
|
if (!runtime.connection) throw new Error('Home Assistant not connected');
|
|
|
|
const nextState = desiredState === 'on' ? 'on' : 'off';
|
|
const domain = meta.type === 'light' ? 'light' : 'switch';
|
|
const service = nextState === 'on' ? 'turn_on' : 'turn_off';
|
|
await callHomeAssistantService(domain, service, { entity_id: entityId });
|
|
logger.info('Issued Home Assistant command', { entityId, domain, service });
|
|
}
|
|
|
|
async function setAllControllableEntitiesState(desiredState) {
|
|
const ids = getControllableEntityIds();
|
|
if (!ids.length) return;
|
|
const results = await Promise.allSettled(ids.map((id) => setEntityState(id, desiredState)));
|
|
const failures = results.filter((result) => result.status === 'rejected');
|
|
if (failures.length) {
|
|
logger.warn('Some Home Assistant entity state updates failed', {
|
|
desiredState,
|
|
total: ids.length,
|
|
failed: failures.length,
|
|
});
|
|
}
|
|
}
|
|
|
|
function scheduleLightsIdleOffTimer(getState, evaluateLightAutomation) {
|
|
if (!enabled) return;
|
|
if (getControllableEntityIds().length === 0) return;
|
|
if (runtime.lightsIdleOffTimer || runtime.lightsLockState != null || hasActiveDrivers()) {
|
|
return;
|
|
}
|
|
runtime.lightsIdleOffDeadline = Date.now() + LIGHT_IDLE_OFF_MS;
|
|
runtime.lightsIdleOffTimer = setTimeout(async () => {
|
|
runtime.lightsIdleOffTimer = null;
|
|
runtime.lightsIdleOffDeadline = null;
|
|
try {
|
|
await setAllControllableEntitiesState('off');
|
|
const nightVisionResult = turnOffAllRoverNightVision();
|
|
logger.info('Auto-turned off room lights due to no active drivers', {
|
|
idleMs: LIGHT_IDLE_OFF_MS,
|
|
nightVisionRovers: nightVisionResult.attempted,
|
|
nightVisionFailures: nightVisionResult.failed,
|
|
nightVisionRoverIds: nightVisionResult.roverIds,
|
|
});
|
|
} catch (err) {
|
|
logger.warn('Failed auto light-off after idle', err.message);
|
|
} finally {
|
|
emitUpdate(getState);
|
|
evaluateLightAutomation();
|
|
}
|
|
}, LIGHT_IDLE_OFF_MS);
|
|
emitUpdate(getState);
|
|
}
|
|
|
|
function triggerMatches(trigger, raw, runtimeState) {
|
|
if (!raw) return false;
|
|
const nextState = raw?.state ?? null;
|
|
const nextChanged = raw?.last_changed ?? null;
|
|
const nextUpdated = raw?.last_updated ?? null;
|
|
const changed =
|
|
runtimeState.lastState !== nextState ||
|
|
runtimeState.lastChanged !== nextChanged ||
|
|
runtimeState.lastUpdated !== nextUpdated;
|
|
if (!changed) {
|
|
return { matched: false, nextState, nextChanged, nextUpdated };
|
|
}
|
|
if (trigger.stateEquals != null && String(trigger.stateEquals) !== String(nextState)) {
|
|
return { matched: false, nextState, nextChanged, nextUpdated };
|
|
}
|
|
return { matched: true, nextState, nextChanged, nextUpdated };
|
|
}
|
|
|
|
function dispatchButtonAction(trigger, runtimeState, payload = {}) {
|
|
const now = Date.now();
|
|
const mode = String(getMode() || '').toLowerCase();
|
|
if (trigger.allowedModes?.length && !trigger.allowedModes.includes(mode)) return;
|
|
if (trigger.cooldownMs > 0 && now - runtimeState.lastFiredAt < trigger.cooldownMs) return;
|
|
runtimeState.lastFiredAt = now;
|
|
triggerRuntime.set(trigger.runtimeKey, runtimeState);
|
|
const basePayload = {
|
|
buttonId: trigger.action,
|
|
action: trigger.action,
|
|
firedAt: now,
|
|
...(payload || {}),
|
|
...(trigger.payload || {}),
|
|
};
|
|
logger.info('Home Assistant button action fired', {
|
|
action: trigger.action,
|
|
source: 'entity',
|
|
entityId: payload?.entityId || null,
|
|
});
|
|
events.emit('trigger', basePayload);
|
|
publishEvent({ source: 'homeAssistant', type: HA_BUTTON_EVENT_TYPE, payload: basePayload });
|
|
}
|
|
|
|
function evaluateTriggers(snapshot = {}) {
|
|
if (!triggerConfig.length) return;
|
|
triggerConfig.forEach((trigger) => {
|
|
const runtimeState = triggerRuntime.get(trigger.runtimeKey) || {
|
|
lastFiredAt: 0,
|
|
lastState: null,
|
|
lastChanged: null,
|
|
lastUpdated: null,
|
|
};
|
|
const raw = snapshot?.[trigger.entityId] || null;
|
|
const evalResult = triggerMatches(trigger, raw, runtimeState);
|
|
runtimeState.lastState = evalResult.nextState;
|
|
runtimeState.lastChanged = evalResult.nextChanged;
|
|
runtimeState.lastUpdated = evalResult.nextUpdated;
|
|
triggerRuntime.set(trigger.runtimeKey, runtimeState);
|
|
if (!evalResult.matched) return;
|
|
dispatchButtonAction(trigger, runtimeState, {
|
|
entityId: trigger.entityId,
|
|
state: raw?.state ?? null,
|
|
attributes: raw?.attributes || {},
|
|
lastChanged: raw?.last_changed || null,
|
|
lastUpdated: raw?.last_updated || null,
|
|
});
|
|
});
|
|
}
|
|
|
|
function getLightPolicyState() {
|
|
return {
|
|
locked: runtime.lightsLockState != null,
|
|
lockState: runtime.lightsLockState,
|
|
lockedOn: runtime.lightsLockState === 'on',
|
|
idleOffMs: LIGHT_IDLE_OFF_MS,
|
|
idleOffAt: runtime.lightsIdleOffDeadline,
|
|
activeDrivers: getActiveDriverCount(),
|
|
};
|
|
}
|
|
|
|
function getState() {
|
|
const entities = Array.from(entityConfig.values()).map((meta) => entityState.get(meta.id) || buildState(meta, null));
|
|
return {
|
|
enabled,
|
|
connected: runtime.connected,
|
|
entities,
|
|
lightPolicy: getLightPolicyState(),
|
|
};
|
|
}
|
|
|
|
function evaluateLightAutomation() {
|
|
if (runtime.lightsLockState != null) {
|
|
clearLightsIdleOffTimer(getState);
|
|
return;
|
|
}
|
|
if (hasActiveDrivers()) {
|
|
clearLightsIdleOffTimer(getState);
|
|
return;
|
|
}
|
|
scheduleLightsIdleOffTimer(getState, evaluateLightAutomation);
|
|
}
|
|
|
|
function handleEntitySnapshot(snapshot = {}) {
|
|
runtime.latestEntitySnapshot = snapshot || {};
|
|
events.emit('snapshot', runtime.latestEntitySnapshot);
|
|
let changed = false;
|
|
entityConfig.forEach((meta, id) => {
|
|
const raw = snapshot[id];
|
|
const next = buildState(meta, raw);
|
|
const prev = entityState.get(id);
|
|
if (!prev || prev.state !== next.state || prev.available !== next.available || prev.lastChanged !== next.lastChanged) {
|
|
entityState.set(id, next);
|
|
changed = true;
|
|
}
|
|
});
|
|
if (changed) emitUpdate(getState);
|
|
evaluateTriggers(snapshot);
|
|
}
|
|
|
|
async function toggleEntity(entityId) {
|
|
const current = entityState.get(entityId);
|
|
const nextState = current?.state === 'on' ? 'off' : 'on';
|
|
return setEntityState(entityId, nextState);
|
|
}
|
|
|
|
async function setLightColor(entityId, rgbColor) {
|
|
if (!enabled) throw new Error('Home Assistant not configured');
|
|
const meta = entityConfig.get(entityId);
|
|
if (!meta || meta.type !== 'light') throw new Error('Home Assistant light required');
|
|
if (!runtime.connection) throw new Error('Home Assistant not connected');
|
|
if (!Array.isArray(rgbColor) || rgbColor.length !== 3) throw new Error('rgbColor required');
|
|
|
|
const normalized = rgbColor.map((value) => {
|
|
const next = Number(value);
|
|
if (Number.isNaN(next)) return 0;
|
|
return Math.max(0, Math.min(255, Math.round(next)));
|
|
});
|
|
await callHomeAssistantService('light', 'turn_on', { entity_id: entityId, rgb_color: normalized });
|
|
logger.info('Issued Home Assistant color command', { entityId, rgbColor: normalized });
|
|
}
|
|
|
|
async function setLightWhite(entityId, kelvin = DEFAULT_WHITE_KELVIN) {
|
|
if (!enabled) throw new Error('Home Assistant not configured');
|
|
const meta = entityConfig.get(entityId);
|
|
if (!meta || meta.type !== 'light') throw new Error('Home Assistant light required');
|
|
if (!runtime.connection) throw new Error('Home Assistant not connected');
|
|
|
|
const nextKelvin = Number(kelvin);
|
|
const normalizedKelvin = Number.isFinite(nextKelvin)
|
|
? Math.max(2000, Math.min(6500, Math.round(nextKelvin)))
|
|
: DEFAULT_WHITE_KELVIN;
|
|
await callHomeAssistantService('light', 'turn_on', { entity_id: entityId, color_temp_kelvin: normalizedKelvin });
|
|
logger.info('Issued Home Assistant white command', { entityId, colorTempKelvin: normalizedKelvin });
|
|
}
|
|
|
|
function isLightControlLocked() {
|
|
return runtime.lightsLockState != null;
|
|
}
|
|
|
|
async function setLightsLockedOn(nextValue, options = {}) {
|
|
const next = Boolean(nextValue);
|
|
const targetState = options?.targetState === 'off' ? 'off' : 'on';
|
|
const forceApply = Boolean(options.forceApply);
|
|
const nextLockState = next ? targetState : null;
|
|
const changed = runtime.lightsLockState !== nextLockState;
|
|
runtime.lightsLockState = nextLockState;
|
|
|
|
if (runtime.lightsLockState != null) {
|
|
clearLightsIdleOffTimer(getState);
|
|
if ((changed || forceApply) && enabled) {
|
|
await setAllControllableEntitiesState(runtime.lightsLockState);
|
|
}
|
|
} else {
|
|
evaluateLightAutomation();
|
|
}
|
|
|
|
if (changed) {
|
|
logger.info('Room lights lock state changed', {
|
|
locked: runtime.lightsLockState != null,
|
|
lockState: runtime.lightsLockState,
|
|
source: options.source || 'unknown',
|
|
});
|
|
}
|
|
emitUpdate(getState);
|
|
return runtime.lightsLockState === 'on';
|
|
}
|
|
|
|
async function toggleLightsLockedOn(options = {}) {
|
|
return setLightsLockedOn(runtime.lightsLockState == null, options);
|
|
}
|
|
|
|
function getRawEntitySnapshot(entityId) {
|
|
if (!entityId) return null;
|
|
return runtime.latestEntitySnapshot?.[String(entityId)] || null;
|
|
}
|
|
|
|
return {
|
|
loadEntityConfig,
|
|
loadTriggerConfig,
|
|
handleEntitySnapshot,
|
|
evaluateLightAutomation,
|
|
emitStatus,
|
|
getState,
|
|
getLightPolicyState,
|
|
isLightControlLocked,
|
|
getRawEntitySnapshot,
|
|
toggleEntity,
|
|
setEntityState,
|
|
setLightColor,
|
|
setLightWhite,
|
|
setLightsLockedOn,
|
|
toggleLightsLockedOn,
|
|
};
|
|
}
|
|
|
|
module.exports = {
|
|
createRuntimeEngine,
|
|
};
|