@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/esphome/esphome.classes.configflow.ts

@@ -8,12 +8,11 @@ export class EsphomeConfigFlow implements IConfigFlow<IEsphomeConfig> {
     return {
       kind: 'form',
       title: 'Connect ESPHome',
-      description: 'Configure an ESPHome native API device. Snapshot/manual data is supported; live protobuf control is reported explicitly if unavailable.',
+      description: 'Connect directly to the native API of an ESPHome 2025.10 or newer device. Use its 32-byte base64 encryption key when encryption is configured.',
       fields: [
         { name: 'host', label: 'Host', type: 'text', required: true },
         { name: 'port', label: 'Native API port', type: 'number' },
         { name: 'encryptionKey', label: 'Encryption key', type: 'password' },
-        { name: 'password', label: 'Legacy API password', type: 'password' },
       ],
       submit: async (valuesArg) => ({
         kind: 'done',
@@ -25,7 +24,6 @@ export class EsphomeConfigFlow implements IConfigFlow<IEsphomeConfig> {
           deviceName: this.stringValue(candidateArg.metadata?.deviceName),
           encryptionKey: this.stringValue(valuesArg.encryptionKey) || this.stringValue(candidateArg.metadata?.encryptionKey),
           noisePsk: this.stringValue(candidateArg.metadata?.noisePsk),
-          password: this.stringValue(valuesArg.password) || this.stringValue(candidateArg.metadata?.password),
           deviceInfo: {
             name: this.stringValue(candidateArg.metadata?.deviceName) || candidateArg.name,
             friendlyName: candidateArg.name,

package/ts/integrations/esphome/esphome.classes.integration.ts

@@ -1,11 +1,11 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { EsphomeClient } from './esphome.classes.client.js';
 import { EsphomeConfigFlow } from './esphome.classes.configflow.js';
 import { createEsphomeDiscoveryDescriptor } from './esphome.discovery.js';
 import { EsphomeMapper } from './esphome.mapper.js';
-import type { IEsphomeClientCommand, IEsphomeConfig } from './esphome.types.js';
+import type { IEsphomeConfig } from './esphome.types.js';
 
 export class EsphomeIntegration extends BaseIntegration<IEsphomeConfig> {
   public readonly domain = 'esphome';
@@ -14,41 +14,57 @@ export class EsphomeIntegration extends BaseIntegration<IEsphomeConfig> {
   public readonly discoveryDescriptor = createEsphomeDiscoveryDescriptor();
   public readonly configFlow = new EsphomeConfigFlow();
   public readonly metadata = {
-    source: 'home-assistant/core',
-    upstreamPath: 'homeassistant/components/esphome',
-    upstreamDomain: 'esphome',
     integrationType: 'device',
     iotClass: 'local_push',
-    qualityScale: 'platinum',
-    requirements: [
-      'aioesphomeapi==44.21.0',
-      'esphome-dashboard-api==1.3.0',
-      'bleak-esphome==3.7.3',
-    ],
-    dependencies: ['assist_pipeline', 'bluetooth', 'intent', 'ffmpeg', 'http'],
-    afterDependencies: ['hassio', 'tag', 'usb', 'zeroconf'],
-    codeowners: ['@jesserockz', '@kbx81', '@bdraco'],
-    documentation: 'https://www.home-assistant.io/integrations/esphome',
+    documentation: 'https://esphome.io/components/api/',
+    nativeApiClient: 'esphome-client@2.0.0',
+    minimumFirmwareVersion: '2025.10',
     zeroconf: ['_esphomelib._tcp.local.'],
-    mqtt: ['esphome/discover/#'],
   };
+  private readonly runtimes = new Set<EsphomeRuntime>();
+  private readonly pendingClients = new Set<EsphomeClient>();
+  private destroyed = false;
 
   public async setup(configArg: IEsphomeConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new EsphomeRuntime(new EsphomeClient(configArg));
+    if (this.destroyed) throw new Error('ESPHome integration was destroyed.');
+    const client = new EsphomeClient(configArg);
+    this.pendingClients.add(client);
+    try {
+      await client.connectLive(contextArg.abortSignal);
+      if (this.destroyed) throw new Error('ESPHome integration was destroyed during setup.');
+      const runtime = new EsphomeRuntime(client, () => this.runtimes.delete(runtime));
+      this.runtimes.add(runtime);
+      return runtime;
+    } catch (error) {
+      await client.destroy();
+      throw error;
+    } finally {
+      this.pendingClients.delete(client);
+    }
   }
 
-  public async destroy(): Promise<void> {}
+  public async destroy(): Promise<void> {
+    this.destroyed = true;
+    await Promise.all([
+      ...[...this.runtimes].map((runtimeArg) => runtimeArg.destroy()),
+      ...[...this.pendingClients].map((clientArg) => clientArg.destroy()),
+    ]);
+  }
 }
 
 export class HomeAssistantEsphomeIntegration extends EsphomeIntegration {}
 
-class EsphomeRuntime implements IIntegrationRuntime {
-  public domain = 'esphome';
+export class EsphomeRuntime implements IIntegrationRuntime {
+  public readonly domain = 'esphome';
+
+  constructor(private readonly client: EsphomeClient, private readonly onDestroy?: () => void) {}
 
-  constructor(private readonly client: EsphomeClient) {}
+  public isHealthy(): boolean {
+    return this.client.isHealthy();
+  }
 
-  public async devices(): Promise<shxInterfaces.data.IDeviceDefinition[]> {
+  public async devices(signalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    signalArg?.throwIfAborted();
     return EsphomeMapper.toDevices(await this.client.getSnapshot());
   }
 
@@ -56,62 +72,41 @@ class EsphomeRuntime implements IIntegrationRuntime {
     return EsphomeMapper.toEntities(await this.client.getSnapshot());
   }
 
-  public async subscribe(handlerArg: (eventArg: IIntegrationEvent) => void): Promise<() => Promise<void>> {
+  public async subscribe(handlerArg: (eventArg: IIntegrationEvent) => void, signalArg?: AbortSignal): Promise<() => Promise<void>> {
+    signalArg?.throwIfAborted();
     const unsubscribe = this.client.onEvent((eventArg) => {
       handlerArg({
-        type: eventArg.type === 'command_mapped' ? 'state_changed' : 'error',
+        type: eventArg.type === 'state_changed' ? 'state_changed' : eventArg.type === 'availability_changed' ? 'availability_changed' : 'error',
         integrationDomain: 'esphome',
         deviceId: eventArg.deviceId,
         entityId: eventArg.entityId,
-        data: eventArg,
+        data: eventArg.data,
         timestamp: eventArg.timestamp || Date.now(),
       });
     });
-    await this.client.getSnapshot();
-    return async () => unsubscribe();
+    const cleanup = () => { unsubscribe(); signalArg?.removeEventListener('abort', cleanup); };
+    signalArg?.addEventListener('abort', cleanup, { once: true });
+    if (signalArg?.aborted) cleanup();
+    return async () => cleanup();
   }
 
   public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    const snapshot = await this.client.getSnapshot();
-    const command = requestArg.domain === 'esphome'
-      ? this.esphomeCommandFromService(requestArg)
-      : EsphomeMapper.commandForService(snapshot, requestArg);
-    if (!command) {
-      return { success: false, error: `ESPHome service ${requestArg.domain}.${requestArg.service} has no safe native command mapping.` };
-    }
-    const result = await this.client.sendCommand(command);
-    return { success: result.success, error: result.error, data: result.data };
+    if (!requestArg.target.entityId && !requestArg.target.deviceId) return { success: false, error: 'ESPHome service calls require an explicit entity or device target.' };
+    const command = EsphomeMapper.commandForService(await this.client.getSnapshot(), requestArg);
+    if (!command) return { success: false, error: `ESPHome service ${requestArg.domain}.${requestArg.service} has no unique supported native command target.` };
+    return this.client.sendCommand(command);
   }
 
-  public async destroy(): Promise<void> {
-    await this.client.destroy();
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, signalArg?: AbortSignal): Promise<IServiceCallResult> {
+    signalArg?.throwIfAborted();
+    if (requestArg.device.integrationDomain !== this.domain) return { success: false, error: 'ESPHome feature writes require an ESPHome device target.' };
+    const command = EsphomeMapper.commandForFeature(await this.client.getSnapshot(), requestArg.device.id, requestArg.feature.id, requestArg.value);
+    if (!command) return { success: false, error: 'ESPHome feature has no supported native command mapping.' };
+    return this.client.sendCommand(command, signalArg);
   }
 
-  private esphomeCommandFromService(requestArg: IServiceCallRequest): IEsphomeClientCommand | undefined {
-    if (requestArg.service === 'send_command' && this.isRecord(requestArg.data?.command)) {
-      return requestArg.data.command as unknown as IEsphomeClientCommand;
-    }
-    if (requestArg.service === 'execute_service' || requestArg.service === 'execute_action') {
-      const name = requestArg.data?.name;
-      if (typeof name !== 'string' || !name) {
-        return undefined;
-      }
-      return {
-        type: 'execute_service',
-        service: name,
-        payload: this.isRecord(requestArg.data?.data) ? requestArg.data.data : {},
-        target: requestArg.target,
-      };
-    }
-    return {
-      type: 'execute_service',
-      service: requestArg.service,
-      payload: requestArg.data || {},
-      target: requestArg.target,
-    };
-  }
-
-  private isRecord(valueArg: unknown): valueArg is Record<string, unknown> {
-    return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+  public async destroy(): Promise<void> {
+    await this.client.destroy();
+    this.onDestroy?.();
   }
 }

package/ts/integrations/esphome/esphome.discovery.ts

@@ -15,7 +15,7 @@ export class EsphomeMdnsMatcher implements IDiscoveryMatcher<IEsphomeMdnsRecord>
     const txt = recordArg.txt || recordArg.properties || {};
     const mac = this.normalizeMac(this.txt(txt, 'mac'));
     const deviceName = this.deviceName(recordArg, txt);
-    const matched = esphomeMdnsTypes.has(type) || Boolean(mac || this.txt(txt, 'api_encryption') || this.txt(txt, 'friendly_name'));
+    const matched = esphomeMdnsTypes.has(type);
     if (!matched) {
       return { matched: false, confidence: 'low', reason: 'mDNS record is not an ESPHome native API advertisement.' };
     }

package/ts/integrations/esphome/esphome.mapper.ts

@@ -3,6 +3,20 @@ import type { IIntegrationEntity, IServiceCallRequest, TEntityPlatform } from '.
 import type { IEsphomeAreaInfo, IEsphomeClientCommand, IEsphomeConfig, IEsphomeDeviceInfo, IEsphomeEntityDescriptor, IEsphomeEntityState, IEsphomeManualEntry, IEsphomeSnapshot } from './esphome.types.js';
 import { esphomeDefaultNativeApiPort } from './esphome.types.js';
 
+const serviceDataFields = new Map<string, readonly string[]>([
+  ['turn_on', []],
+  ['turn_off', []],
+  ['set_value', ['value']],
+  ['press', []],
+  ['set_position', ['position', 'positionPercentage', 'position_percentage']],
+  ['set_percentage', ['percentage']],
+  ['select_option', ['option']],
+  ['open_cover', []],
+  ['close_cover', []],
+  ['stop_cover', []],
+  ['set_temperature', ['temperature']],
+]);
+
 export class EsphomeMapper {
   public static toSnapshot(configArg: IEsphomeConfig, connectedArg?: boolean, eventsArg: IEsphomeSnapshot['events'] = []): IEsphomeSnapshot {
     const source = configArg.snapshot;
@@ -37,13 +51,13 @@ export class EsphomeMapper {
       protocol: 'esphome',
       manufacturer: this.manufacturer(deviceInfo),
       model: this.model(deviceInfo),
-      online: snapshotArg.connected || Boolean(snapshotArg.entities.length || snapshotArg.states.length),
+      online: snapshotArg.connected,
       features: [
         { id: 'connection', capability: 'sensor', name: 'Connection', readable: true, writable: false },
         { id: 'entity_count', capability: 'sensor', name: 'Entity count', readable: true, writable: false },
       ],
       state: [
-        { featureId: 'connection', value: snapshotArg.connected ? 'connected' : 'configured', updatedAt },
+        { featureId: 'connection', value: snapshotArg.connected ? 'connected' : 'disconnected', updatedAt },
         { featureId: 'entity_count', value: snapshotArg.entities.length, updatedAt },
       ],
       metadata: {
@@ -74,7 +88,7 @@ export class EsphomeMapper {
         protocol: 'esphome',
         manufacturer: this.manufacturer(deviceInfo),
         model: this.model(deviceInfo),
-        online: snapshotArg.connected || Boolean(snapshotArg.entities.length || snapshotArg.states.length),
+        online: snapshotArg.connected,
         features: [],
         state: [],
         metadata: {
@@ -126,7 +140,7 @@ export class EsphomeMapper {
           rawState: state,
           rawInfo: entityArg.raw,
         },
-        available: !this.missingState(state),
+        available: snapshotArg.connected && state !== undefined && !this.missingState(state),
       };
     });
   }
@@ -154,6 +168,34 @@ export class EsphomeMapper {
     };
   }
 
+  public static commandForFeature(snapshotArg: IEsphomeSnapshot, deviceIdArg: string, featureIdArg: string, valueArg: unknown): IEsphomeClientCommand | undefined {
+    const entity = snapshotArg.entities.find((entityArg) => this.deviceIdForEntity(snapshotArg, entityArg) === deviceIdArg && this.featureForEntity(entityArg).id === featureIdArg);
+    if (!entity || !this.entityWritable(entity)) return undefined;
+    const target = { entityId: entity.entityId || entity.entity_id || this.uniqueIdForEntity(snapshotArg, entity) };
+    let request: IServiceCallRequest;
+    switch (entity.platform) {
+      case 'light':
+      case 'switch':
+      case 'fan':
+        if (typeof valueArg !== 'boolean' && valueArg !== 'on' && valueArg !== 'off') return undefined;
+        request = { domain: entity.platform, service: valueArg === true || valueArg === 'on' ? 'turn_on' : 'turn_off', target };
+        break;
+      case 'number':
+      case 'text':
+        request = { domain: entity.platform, service: 'set_value', data: { value: valueArg }, target };
+        break;
+      case 'select':
+        request = { domain: entity.platform, service: 'select_option', data: { option: valueArg }, target };
+        break;
+      case 'cover':
+        if (typeof valueArg !== 'number' || !Number.isFinite(valueArg) || valueArg < 0 || valueArg > 100) return undefined;
+        request = { domain: 'cover', service: 'set_position', data: { position: valueArg }, target };
+        break;
+      default: return undefined;
+    }
+    return this.commandForService(snapshotArg, request);
+  }
+
   public static corePlatform(platformArg: string): TEntityPlatform {
     const platform = platformArg.toLowerCase();
     if (platform === 'text_sensor') {
@@ -261,16 +303,24 @@ export class EsphomeMapper {
   }
 
   private static payloadForService(entityArg: IEsphomeEntityDescriptor, requestArg: IServiceCallRequest): Record<string, unknown> | undefined {
+    const allowedFields = serviceDataFields.get(requestArg.service);
+    if (!allowedFields) return undefined;
+    const data: Record<string, unknown> = Object.create(null);
+    if (requestArg.data) {
+      const prototype = Object.getPrototypeOf(requestArg.data);
+      if (prototype !== Object.prototype && prototype !== null) return undefined;
+      for (const key of Reflect.ownKeys(requestArg.data)) {
+        const descriptor = Object.getOwnPropertyDescriptor(requestArg.data, key);
+        if (typeof key !== 'string' || !allowedFields.includes(key) || !descriptor || !('value' in descriptor)) return undefined;
+        data[key] = descriptor.value;
+      }
+    }
     const platform = this.corePlatform(entityArg.platform);
     if (requestArg.service === 'turn_on') {
       if (!['light', 'switch', 'fan', 'climate'].includes(platform)) {
         return undefined;
       }
-      return {
-        state: true,
-        ...this.lightPayload(requestArg),
-        ...this.fanPayload(requestArg),
-      };
+      return { state: true };
     }
     if (requestArg.service === 'turn_off') {
       if (!['light', 'switch', 'fan', 'climate'].includes(platform)) {
@@ -279,24 +329,25 @@ export class EsphomeMapper {
       return { state: false };
     }
     if (requestArg.service === 'set_value') {
-      if (!['number', 'text'].includes(platform) || requestArg.data?.value === undefined) {
+      if (!['number', 'text'].includes(platform) || data.value === undefined) {
         return undefined;
       }
-      return { value: requestArg.data.value };
+      return { value: data.value };
     }
     if (requestArg.service === 'press') {
       return platform === 'button' ? { press: true } : undefined;
     }
     if (requestArg.service === 'set_position') {
-      const position = this.numberValue(requestArg.data?.position ?? requestArg.data?.positionPercentage ?? requestArg.data?.position_percentage);
-      return platform === 'cover' && position !== undefined ? { position: this.percentToFraction(position), positionPercentage: this.clampPercent(position) } : undefined;
+      if (Object.keys(data).length !== 1) return undefined;
+      const position = this.numberValue(data.position ?? data.positionPercentage ?? data.position_percentage);
+      return platform === 'cover' && position !== undefined && position >= 0 && position <= 100 ? { position: this.percentToFraction(position), positionPercentage: position } : undefined;
     }
     if (requestArg.service === 'set_percentage') {
-      const percentage = this.numberValue(requestArg.data?.percentage);
+      const percentage = this.numberValue(data.percentage);
       return platform === 'fan' && percentage !== undefined ? { state: percentage > 0, percentage: this.clampPercent(percentage) } : undefined;
     }
     if (requestArg.service === 'select_option') {
-      const option = requestArg.data?.option;
+      const option = data.option;
       return platform === 'select' && typeof option === 'string' ? { option } : undefined;
     }
     if (requestArg.service === 'open_cover') {
@@ -309,7 +360,7 @@ export class EsphomeMapper {
       return platform === 'cover' ? { stop: true } : undefined;
     }
     if (requestArg.service === 'set_temperature') {
-      const temperature = this.numberValue(requestArg.data?.temperature);
+      const temperature = this.numberValue(data.temperature);
       return platform === 'climate' && temperature !== undefined ? { targetTemperature: temperature } : undefined;
     }
     return undefined;
@@ -321,13 +372,15 @@ export class EsphomeMapper {
       if (!entity) {
         return undefined;
       }
+      if (requestArg.target.deviceId && entity.deviceId !== requestArg.target.deviceId) return undefined;
       const target = snapshotArg.entities.find((entityArg) => this.uniqueIdForEntity(snapshotArg, entityArg) === entity.uniqueId);
       return target && this.serviceMatchesEntity(target, requestArg) ? target : undefined;
     }
     const candidates = requestArg.target.deviceId
       ? snapshotArg.entities.filter((entityArg) => this.deviceIdForEntity(snapshotArg, entityArg) === requestArg.target.deviceId)
       : snapshotArg.entities;
-    return candidates.find((entityArg) => this.serviceMatchesEntity(entityArg, requestArg));
+    const matches = candidates.filter((entityArg) => this.serviceMatchesEntity(entityArg, requestArg));
+    return matches.length === 1 ? matches[0] : undefined;
   }
 
   private static serviceMatchesEntity(entityArg: IEsphomeEntityDescriptor, requestArg: IServiceCallRequest): boolean {
@@ -335,6 +388,7 @@ export class EsphomeMapper {
       return false;
     }
     const domainPlatform = this.domainPlatform(requestArg.domain);
+    if (requestArg.domain !== 'esphome' && domainPlatform === undefined) return false;
     if (domainPlatform && this.corePlatform(entityArg.platform) !== domainPlatform) {
       return false;
     }
@@ -461,26 +515,6 @@ export class EsphomeMapper {
     return stateArg?.missingState === true || stateArg?.missing_state === true;
   }
 
-  private static lightPayload(requestArg: IServiceCallRequest): Record<string, unknown> {
-    const brightness = this.numberValue(requestArg.data?.brightness);
-    const transition = this.numberValue(requestArg.data?.transition);
-    const effect = requestArg.data?.effect;
-    return {
-      ...(brightness !== undefined ? { brightness: this.clampPercent(brightness / 255 * 100) / 100 } : {}),
-      ...(transition !== undefined ? { transitionLength: transition } : {}),
-      ...(typeof effect === 'string' ? { effect } : {}),
-    };
-  }
-
-  private static fanPayload(requestArg: IServiceCallRequest): Record<string, unknown> {
-    const percentage = this.numberValue(requestArg.data?.percentage);
-    const presetMode = requestArg.data?.presetMode ?? requestArg.data?.preset_mode;
-    return {
-      ...(percentage !== undefined ? { percentage: this.clampPercent(percentage) } : {}),
-      ...(typeof presetMode === 'string' ? { presetMode } : {}),
-    };
-  }
-
   private static percentToFraction(valueArg: number): number {
     return this.clampPercent(valueArg) / 100;
   }

package/ts/integrations/esphome/esphome.types.ts

@@ -23,6 +23,8 @@ export interface IEsphomeConfig {
   password?: string;
   encryptionKey?: string;
   noisePsk?: string;
+  initialSnapshotTimeoutMs?: number;
+  commandTimeoutMs?: number;
   snapshot?: IEsphomeSnapshot;
   deviceInfo?: IEsphomeDeviceInfo;
   entities?: IEsphomeEntityDescriptor[];

package/ts/integrations/esphome/readme.md

@@ -0,0 +1,66 @@
+# ESPHome
+
+This integration connects directly to an ESPHome device's native TCP API through `esphome-client@2.0.0`. It discovers live entities, reads authoritative state, and confirms supported controls against subsequent device state reports.
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
+## Setup
+
+Install the parent package with `pnpm add @smarthome.exchange/integrations`. The native client requires Node.js 22.20 or newer and ESPHome 2025.10 or newer. Configure one native API node per integration instance; its advertised logical sub-devices share that connection.
+
+Provide a host and an optional port, which defaults to `6053`. For an encrypted device, supply its canonical base64-encoded 32-byte key as `encryptionKey` or `noisePsk`. Conflicting keys, legacy API passwords, injected snapshots, and command executors are rejected during live setup. When a key is supplied, a plaintext connection is rejected before controls become available.
+
+```typescript
+import { EsphomeIntegration } from '@smarthome.exchange/integrations';
+
+async function inspectNode(host: string, encryptionKey: string) {
+  const integration = new EsphomeIntegration();
+  try {
+    const runtime = await integration.setup({ host, encryptionKey }, {
+      abortSignal: AbortSignal.timeout(15_000),
+    });
+    return await runtime.devices();
+  } finally {
+    await integration.destroy();
+  }
+}
+```
+
+Obtain encryption keys through the application's secret provisioning flow. Discovery metadata does not prove a device's identity or grant authority to control it. The caller remains responsible for home access and tool authorization.
+
+## State and controls
+
+Setup waits for every advertised readable entity to report state within `initialSnapshotTimeoutMs`, which defaults to 15 seconds. A node that suppresses an initial state for a readable entity fails setup. Reconnection clears the native client's cached states; the runtime becomes healthy again only after fresh initial states arrive. Disconnected devices and their entities are unavailable. Public entity identifiers include the node identity, platform, native key, and sub-device identity, so identical object names on separate nodes remain distinct.
+
+Readable platforms are lights, switches, fans, covers, climate entities, numbers, selects, text, sensors, binary sensors, and text sensors. Supported writes are light/switch/fan power, advertised cover position, bounded numbers, advertised select options, and bounded text. Climate controls, button presses, brightness/color changes, fan speed, cover stop/tilt, and user-service execution are unsupported.
+
+Use `runtime.writeFeature` with a device and feature returned by that runtime, or `runtime.callService` with an explicit entity or device target. A device target must select exactly one supported entity. Supplying both targets requires them to name the same device. Foreign integration devices, unrelated service domains, out-of-range cover positions, and unknown service settings are rejected. Service data must contain ordinary values without accessors or symbol fields. The `esphome` service domain can select a supported native entity; platform domains must match the selected entity.
+
+Each entity admits one pending command. Success requires a subsequent matching state report within `commandTimeoutMs`, which defaults to 5 seconds. A matching report confirms the observed state; the protocol does not supply a unique action receipt or exactly-once physical execution guarantee. Timeout or cancellation can follow a physical effect, so failed or interrupted commands must not be retried automatically. Destruction disconnects the node, removes subscriptions, and cancels setup and pending confirmations.
+
+Verification uses real plaintext and Noise-encrypted local TCP fixtures plus the published native client's encoder/decoder and `MockTransport`. Real hardware behavior has not been verified in this lane.
+
+Protocol references: [ESPHome native API](https://esphome.io/components/api/) and [esphome-client documentation](https://github.com/hjdhjd/esphome-client#readme).
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [repository license file](../../../license.md).
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH<br>
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

package/ts/integrations/generated/index.ts

@@ -814,7 +814,6 @@ import { HomeAssistantTami4Integration } from '../tami4/index.js';
 import { HomeAssistantTankUtilityIntegration } from '../tank_utility/index.js';
 import { HomeAssistantTankerkoenigIntegration } from '../tankerkoenig/index.js';
 import { HomeAssistantTapsaffIntegration } from '../tapsaff/index.js';
-import { HomeAssistantTasmotaIntegration } from '../tasmota/index.js';
 import { HomeAssistantTautulliIntegration } from '../tautulli/index.js';
 import { HomeAssistantTcpIntegration } from '../tcp/index.js';
 import { HomeAssistantTechnoveIntegration } from '../technove/index.js';
@@ -882,7 +881,6 @@ import { HomeAssistantTrendIntegration } from '../trend/index.js';
 import { HomeAssistantTriggercmdIntegration } from '../triggercmd/index.js';
 import { HomeAssistantTrmnlIntegration } from '../trmnl/index.js';
 import { HomeAssistantTtsIntegration } from '../tts/index.js';
-import { HomeAssistantTuyaIntegration } from '../tuya/index.js';
 import { HomeAssistantTwentemilieuIntegration } from '../twentemilieu/index.js';
 import { HomeAssistantTwilioIntegration } from '../twilio/index.js';
 import { HomeAssistantTwilioCallIntegration } from '../twilio_call/index.js';
@@ -1817,7 +1815,6 @@ generatedHomeAssistantPortIntegrations.push(new HomeAssistantTami4Integration())
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTankUtilityIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTankerkoenigIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTapsaffIntegration());
-generatedHomeAssistantPortIntegrations.push(new HomeAssistantTasmotaIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTautulliIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTcpIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTechnoveIntegration());
@@ -1885,7 +1882,6 @@ generatedHomeAssistantPortIntegrations.push(new HomeAssistantTrendIntegration())
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTriggercmdIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTrmnlIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTtsIntegration());
-generatedHomeAssistantPortIntegrations.push(new HomeAssistantTuyaIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTwentemilieuIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTwilioIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantTwilioCallIntegration());
@@ -2006,7 +2002,7 @@ generatedHomeAssistantPortIntegrations.push(new HomeAssistantZondergasIntegratio
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantZoneIntegration());
 generatedHomeAssistantPortIntegrations.push(new HomeAssistantZwaveMeIntegration());
 
-export const generatedHomeAssistantPortCount = 1001;
+export const generatedHomeAssistantPortCount = 999;
 export const handwrittenHomeAssistantPortDomains = [
   "acaia",
   "acer_projector",
@@ -2218,8 +2214,8 @@ export const handwrittenHomeAssistantPortDomains = [
   "hitron_coda",
   "hlk_sw16",
   "holiday",
-  "homee",
   "homeassistant",
+  "homee",
   "homekit",
   "homekit_controller",
   "homematic",
@@ -2423,12 +2419,14 @@ export const handwrittenHomeAssistantPortDomains = [
   "squeezebox",
   "synology_dsm",
   "synology_srm",
+  "tasmota",
   "tomato",
   "tplink",
   "tplink_lte",
   "tplink_omada",
   "tradfri",
   "transmission",
+  "tuya",
   "twinkly",
   "ubus",
   "unifi",