fix(iobroker): stream energy live_status/site_info in default streaming mode (#115)

* fix(iobroker): stream energy live_status/site_info in default streaming mode

Energy data was fetched once at startup and then never updated when
streaming was enabled (the default), since StreamHandler only listened
to vehicle topics. Register live_status/site_info listeners alongside
the existing vehicle ones and route them through the same flat energy
parser used by the REST seed, so energy states keep updating from the
stream instead of freezing after the initial fetch.

* fix(iobroker): ignore energy stream events for unregistered sites

live_status/site_info arrive on the account-level stream for every
accessible site, not just the ones this adapter instance selected -
without a check, an unselected site's events wrote to object paths
that were never created. Filter both handlers against
EnergyHandler.getRegisteredSites() before forwarding to the parser.

* fix(iobroker): seed energy state before opening the SSE stream

streamHandler.connect() only starts the SDK's background reconnect
loop and returns immediately, so the previous ordering let a
live_status/site_info event land before the initial energy REST
fetch resolved - the fetch would then overwrite it with a stale
snapshot. Fetch energy state first, then open the stream.

Author: Bre77

.changeset/iob-energy-live-streaming.md

@@ -0,0 +1,5 @@
+---
+"iobroker.teslemetry": patch
+---
+
+Consume `live_status`/`site_info` SSE events per energy site so energy data keeps updating in the default streaming mode, instead of freezing after the initial startup fetch. The REST fetch still seeds a deterministic initial value; the stream now keeps it current afterward without polling.

packages/iobroker.teslemetry/README.md

@@ -24,10 +24,10 @@ ioBroker adapter for controlling Tesla vehicles and energy sites via the Tesleme
 - 🏠 **Off-Grid** - Configure backup reserves
 
 ### Real-Time Updates
-- 📡 **SSE Streaming** - Live vehicle updates via Server-Sent Events
+- 📡 **SSE Streaming** - Live vehicle and energy site updates via Server-Sent Events
 - 🔄 **Automatic Reconnection** - Robust connection handling
 - 💤 **Sleep Mode Aware** - Won't wake sleeping vehicles unnecessarily
-- 📊 **Polling** - Energy site data updates via polling; vehicles can also use polling instead of streaming
+- 📊 **Polling** - Optional fallback for vehicles and energy sites when streaming is disabled
 
 ## Prerequisites
 
@@ -82,12 +82,11 @@ npm install iobroker.teslemetry
 
 **Real-time Streaming (recommended)**
 - Enable **"Enable real-time streaming (SSE)"**
-- Provides instant updates when vehicle data changes
+- Provides instant updates when vehicle or energy site data changes
 - More efficient and responsive than polling
-- Energy site data is always updated via polling, regardless of this setting
 
 **Polling Mode**
-- Disable streaming to use polling instead for vehicles too
+- Disable streaming to use polling instead for both vehicles and energy sites
 - Set **Poll Interval** (minimum 30 seconds)
 - Less efficient but works if streaming has issues
 

packages/iobroker.teslemetry/lib/StateManager.ts

@@ -243,8 +243,11 @@ export class StateManager {
 	}
 
 	/**
-	 * Update energy site data from the merged { ...siteInfo.response, ...liveStatus.response }
-	 * of getSiteInfo() and getLiveStatus() - both are flat, no `live_status` wrapper.
+	 * Update energy site data from a flat object matching the REST getSiteInfo()/getLiveStatus()
+	 * response shape - either their merged `{ ...siteInfo.response, ...liveStatus.response }`
+	 * (the REST seed), or a single SSE `live_status`/`site_info` event's payload (both are
+	 * flat, no wrapper, and use the same field names as their REST counterparts). Every field
+	 * is optional, so a partial single-topic payload only touches the states it carries.
 	 */
 	async updateEnergySiteData(siteId: number, data: any): Promise<void> {
 		const base = `energy.${siteId}`;

packages/iobroker.teslemetry/lib/StreamHandler.ts

@@ -1,5 +1,6 @@
 import { Teslemetry } from '@teslemetry/api';
 import { StateManager } from './StateManager.js';
+import { EnergyHandler } from './EnergyHandler.js';
 
 export class StreamHandler {
 	private reconnectAttempts = 0;
@@ -10,7 +11,8 @@ export class StreamHandler {
 	constructor(
 		private adapter: ioBroker.Adapter,
 		private teslemetry: Teslemetry,
-		private stateManager: StateManager
+		private stateManager: StateManager,
+		private energyHandler: EnergyHandler
 	) {}
 
 	/**
@@ -58,6 +60,16 @@ export class StreamHandler {
 				this.handleAlertEvent(event);
 			});
 
+			// Handle energy site live power/battery/grid updates
+			sse.on('live_status', (event: any) => {
+				this.handleLiveStatusEvent(event);
+			});
+
+			// Handle energy site settings updates (operation mode, reserves, ...)
+			sse.on('site_info', (event: any) => {
+				this.handleSiteInfoEvent(event);
+			});
+
 			// Connect to stream
 			await sse.connect();
 		} catch (error: any) {
@@ -145,6 +157,52 @@ export class StreamHandler {
 		}
 	}
 
+	/**
+	 * Handle energy site `live_status` events (solar/battery/grid/load power, SOC)
+	 */
+	private async handleLiveStatusEvent(event: any): Promise<void> {
+		try {
+			const { site_id, live_status } = event;
+
+			if (!site_id || !live_status) {
+				return;
+			}
+
+			const siteId = Number(site_id);
+			if (!this.energyHandler.getRegisteredSites().includes(siteId)) {
+				return;
+			}
+
+			this.adapter.log.debug(`Received live_status event for energy site ${site_id}`);
+			await this.stateManager.updateEnergySiteData(siteId, live_status);
+		} catch (error: any) {
+			this.adapter.log.error(`Error handling live_status event: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Handle energy site `site_info` events (operation mode, reserves, tariff id, ...)
+	 */
+	private async handleSiteInfoEvent(event: any): Promise<void> {
+		try {
+			const { site_id, site_info } = event;
+
+			if (!site_id || !site_info) {
+				return;
+			}
+
+			const siteId = Number(site_id);
+			if (!this.energyHandler.getRegisteredSites().includes(siteId)) {
+				return;
+			}
+
+			this.adapter.log.debug(`Received site_info event for energy site ${site_id}`);
+			await this.stateManager.updateEnergySiteData(siteId, site_info);
+		} catch (error: any) {
+			this.adapter.log.error(`Error handling site_info event: ${error.message}`);
+		}
+	}
+
 	/**
 	 * Schedule automatic reconnection with exponential backoff
 	 */

packages/iobroker.teslemetry/src/main.ts

@@ -112,23 +112,26 @@ class TeslemetryAdapter extends utils.Adapter {
 			// Subscribe to all state changes
 			this.subscribeStates('*');
 
+			// Seed energy state before opening the stream - connect() only starts the SDK's
+			// background loop and returns immediately, so a stream event could otherwise land
+			// before this REST fetch resolves and get overwritten by the stale snapshot.
+			this.log.info('Fetching initial energy site data...');
+			await this.energyHandler.fetchAllSiteData();
+
 			// Set up streaming or polling
 			if (this.config.enableStreaming !== false) {
 				this.log.info('Starting SSE streaming...');
-				this.streamHandler = new StreamHandler(this, this.teslemetry, this.stateManager);
+				this.streamHandler = new StreamHandler(this, this.teslemetry, this.stateManager, this.energyHandler);
 				await this.streamHandler.connect();
 			} else {
 				this.log.info('SSE streaming disabled, using polling');
 				this.startPolling();
 			}
 
-			// Do initial data fetch
+			// Do initial vehicle data fetch
 			this.log.info('Fetching initial vehicle data...');
 			await this.vehicleHandler.fetchAllVehicleData(false);
 
-			this.log.info('Fetching initial energy site data...');
-			await this.energyHandler.fetchAllSiteData();
-
 			this.log.info('Teslemetry adapter started successfully');
 			await this.setStateAsync('info.connection', true, true);
 		} catch (error: any) {

packages/iobroker.teslemetry/test/StreamHandler.test.ts

@@ -3,17 +3,20 @@ import assert from 'node:assert/strict';
 import { Teslemetry } from '@teslemetry/api';
 import { StreamHandler } from '../lib/StreamHandler.js';
 import { StateManager } from '../lib/StateManager.js';
+import { EnergyHandler } from '../lib/EnergyHandler.js';
 import { createFakeAdapter } from './fakeAdapter.js';
 
 const VIN = '5YJSA1E14FF000000';
+const SITE_ID = 123;
 
 test('data events update states via the SSE flat-signal parser', async () => {
 	const teslemetry = new Teslemetry('fake-token');
 	// Avoid a real network connection; sse.connect() only needs to resolve.
 	(teslemetry.sse as any).connect = () => Promise.resolve();
 
 	const { adapter, states } = createFakeAdapter();
-	const streamHandler = new StreamHandler(adapter, teslemetry, new StateManager(adapter));
+	const stateManager = new StateManager(adapter);
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, new EnergyHandler(adapter, teslemetry, stateManager));
 	await streamHandler.connect();
 
 	teslemetry.sse.emit('data', { vin: VIN, data: { BatteryLevel: 71 } } as any);
@@ -28,7 +31,8 @@ test('alert events log each alert from the `alerts` array (regression: destructu
 	(teslemetry.sse as any).connect = () => Promise.resolve();
 
 	const { adapter, logs } = createFakeAdapter();
-	const streamHandler = new StreamHandler(adapter, teslemetry, new StateManager(adapter));
+	const stateManager = new StateManager(adapter);
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, new EnergyHandler(adapter, teslemetry, stateManager));
 	await streamHandler.connect();
 
 	teslemetry.sse.emit('alerts', {
@@ -42,3 +46,84 @@ test('alert events log each alert from the `alerts` array (regression: destructu
 		`expected an alert log line, got: ${JSON.stringify(logs)}`,
 	);
 });
+
+test('live_status events update energy live-power states (regression: default streaming mode never wired up energy topics)', async () => {
+	const teslemetry = new Teslemetry('fake-token');
+	(teslemetry.sse as any).connect = () => Promise.resolve();
+
+	const { adapter, states } = createFakeAdapter();
+	const stateManager = new StateManager(adapter);
+	const energyHandler = new EnergyHandler(adapter, teslemetry, stateManager);
+	energyHandler.registerSite(SITE_ID);
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, energyHandler);
+	await streamHandler.connect();
+
+	teslemetry.sse.emit('live_status', { site_id: String(SITE_ID), live_status: { solar_power: 900, grid_status: 'Active' } } as any);
+	await new Promise((resolve) => setTimeout(resolve, 0));
+
+	assert.equal(states.get(`energy.${SITE_ID}.live.solar_power`), 900);
+	assert.equal(states.get(`energy.${SITE_ID}.live.grid_status`), 'Active');
+});
+
+test('site_info events update energy operation states', async () => {
+	const teslemetry = new Teslemetry('fake-token');
+	(teslemetry.sse as any).connect = () => Promise.resolve();
+
+	const { adapter, states } = createFakeAdapter();
+	const stateManager = new StateManager(adapter);
+	const energyHandler = new EnergyHandler(adapter, teslemetry, stateManager);
+	energyHandler.registerSite(SITE_ID);
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, energyHandler);
+	await streamHandler.connect();
+
+	teslemetry.sse.emit('site_info', { site_id: String(SITE_ID), site_info: { default_real_mode: 'backup', backup_reserve_percent: 35 } } as any);
+	await new Promise((resolve) => setTimeout(resolve, 0));
+
+	assert.equal(states.get(`energy.${SITE_ID}.operation.mode`), 'backup');
+	assert.equal(states.get(`energy.${SITE_ID}.operation.backup_reserve_percent`), 35);
+});
+
+test('energy live values change after the REST startup seed via live_status stream events, without polling (regression: default streaming mode left energy frozen after startup)', async () => {
+	const teslemetry = new Teslemetry('fake-token');
+	(teslemetry.sse as any).connect = () => Promise.resolve();
+
+	const site = teslemetry.api.getEnergySite(SITE_ID);
+	(site as any).getLiveStatus = () => Promise.resolve({ response: { solar_power: 500 } });
+	(site as any).getSiteInfo = () => Promise.resolve({ response: {} });
+
+	const { adapter, states } = createFakeAdapter();
+	const stateManager = new StateManager(adapter);
+	const energyHandler = new EnergyHandler(adapter, teslemetry, stateManager);
+	energyHandler.registerSite(SITE_ID);
+
+	// Deterministic REST seed at startup
+	await energyHandler.fetchSiteData(SITE_ID);
+	assert.equal(states.get(`energy.${SITE_ID}.live.solar_power`), 500);
+
+	// The stream - not a poll interval - delivers the next value
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, energyHandler);
+	await streamHandler.connect();
+
+	teslemetry.sse.emit('live_status', { site_id: String(SITE_ID), live_status: { solar_power: 1200 } } as any);
+	await new Promise((resolve) => setTimeout(resolve, 0));
+
+	assert.equal(states.get(`energy.${SITE_ID}.live.solar_power`), 1200);
+});
+
+test('live_status events for an unselected/unregistered energy site are ignored (regression: account-level stream delivers every accessible site, not just the ones this instance registered)', async () => {
+	const teslemetry = new Teslemetry('fake-token');
+	(teslemetry.sse as any).connect = () => Promise.resolve();
+
+	const { adapter, states } = createFakeAdapter();
+	const stateManager = new StateManager(adapter);
+	// Registers a different site; SITE_ID below was never selected for this instance.
+	const energyHandler = new EnergyHandler(adapter, teslemetry, stateManager);
+	energyHandler.registerSite(SITE_ID + 1);
+	const streamHandler = new StreamHandler(adapter, teslemetry, stateManager, energyHandler);
+	await streamHandler.connect();
+
+	teslemetry.sse.emit('live_status', { site_id: String(SITE_ID), live_status: { solar_power: 900 } } as any);
+	await new Promise((resolve) => setTimeout(resolve, 0));
+
+	assert.equal(states.get(`energy.${SITE_ID}.live.solar_power`), undefined);
+});