@smarthome.exchange/integrations 0.2.0 → 1.0.0

package/ts/integrations/roku/roku.classes.configflow.ts

@@ -1,25 +1,32 @@
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { IRokuConfig } from './roku.types.js';
+import { RokuCandidateValidator } from './roku.discovery.js';
+import { readRokuRecord, validateRokuConfig } from './roku.validation.js';
 
 export class RokuConfigFlow implements IConfigFlow<IRokuConfig> {
   public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IRokuConfig>> {
     void contextArg;
+    const candidate = await new RokuCandidateValidator().validate(candidateArg);
+    if (!candidate.matched || !candidate.candidate) return { kind: 'error', error: 'Roku setup requires an admitted Roku candidate.' };
+    const host = candidate.candidate.host;
+    const port = candidate.candidate.port;
     return {
-      kind: 'form',
-      title: 'Connect Roku',
-      description: 'Configure the local Roku External Control Protocol endpoint.',
+      kind: 'form', title: 'Connect Roku',
+      description: 'Enter the UDN reported by query/device-info. Setup verifies this identity before exposing the device.',
       fields: [
-        { name: 'host', label: 'Host', type: 'text', required: true },
-        { name: 'port', label: 'Port', type: 'number' },
+        { name: 'host', label: 'Local IPv4 address', type: 'text', required: true },
+        { name: 'port', label: 'ECP port', type: 'number' },
+        { name: 'udn', label: 'Device UDN', type: 'text', required: true },
       ],
-      submit: async (valuesArg) => ({
-        kind: 'done',
-        title: 'Roku configured',
-        config: {
-          host: String(valuesArg.host || candidateArg.host || ''),
-          port: typeof valuesArg.port === 'number' ? valuesArg.port : candidateArg.port || 8060,
-        },
-      }),
+      submit: async (valuesArg) => {
+        try {
+          const values = readRokuRecord(valuesArg, ['host', 'port', 'udn']);
+          const config = validateRokuConfig({ host: values.host ?? host, port: values.port ?? port, udn: values.udn });
+          return { kind: 'done', title: 'Roku configured', config };
+        } catch (errorArg) {
+          return { kind: 'error', error: errorArg instanceof Error ? errorArg.message : 'Invalid Roku configuration.' };
+        }
+      },
     };
   }
 }

package/ts/integrations/roku/roku.classes.integration.ts

@@ -1,44 +1,66 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { RokuClient } from './roku.classes.client.js';
 import { RokuConfigFlow } from './roku.classes.configflow.js';
 import { createRokuDiscoveryDescriptor } from './roku.discovery.js';
 import { RokuMapper } from './roku.mapper.js';
 import type { IRokuConfig } from './roku.types.js';
+import { normalizeRokuUdn, readRokuRecord, validateRokuAppId, validateRokuKey } from './roku.validation.js';
 
 export class RokuIntegration extends BaseIntegration<IRokuConfig> {
   public readonly domain = 'roku';
   public readonly displayName = 'Roku';
-  public readonly status = 'control-runtime' as const;
+  public readonly status = 'control-runtime';
   public readonly discoveryDescriptor = createRokuDiscoveryDescriptor();
   public readonly configFlow = new RokuConfigFlow();
   public readonly metadata = {
-    source: 'home-assistant/core',
-    upstreamPath: 'homeassistant/components/roku',
-    upstreamDomain: 'roku',
-    integrationType: 'device',
-    iotClass: 'local_polling',
-    qualityScale: 'unknown',
+    source: 'home-assistant/core', upstreamPath: 'homeassistant/components/roku', upstreamDomain: 'roku',
+    integrationType: 'device', iotClass: 'local_polling', qualityScale: 'unknown',
   };
+  private readonly clients = new Set<RokuClient>();
+  private closed = false;
+  private closePromise?: Promise<void>;
 
   public async setup(configArg: IRokuConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new RokuRuntime(new RokuClient(configArg));
+    if (this.closed) throw new Error('Roku integration is closed.');
+    const client = new RokuClient(configArg, { abortSignal: contextArg.abortSignal });
+    this.clients.add(client);
+    try {
+      const snapshot = await client.getSnapshot(contextArg.abortSignal);
+      if (this.closed || client.isClosed) throw new Error('Roku setup was cancelled.');
+      return new RokuRuntime(client, snapshot.deviceInfo.udn, () => this.clients.delete(client));
+    } catch (errorArg) {
+      await client.destroy();
+      this.clients.delete(client);
+      throw errorArg;
+    }
   }
 
-  public async destroy(): Promise<void> {}
+  public destroy(): Promise<void> {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.all([...this.clients].map((clientArg) => clientArg.destroy())).then(() => { this.clients.clear(); });
+    }
+    return this.closePromise;
+  }
 }
 
 export class HomeAssistantRokuIntegration extends RokuIntegration {}
 
 class RokuRuntime implements IIntegrationRuntime {
-  public domain = 'roku';
+  public readonly domain = 'roku';
+  private readonly deviceId: string;
+  private readonly entityId: string;
 
-  constructor(private readonly client: RokuClient) {}
+  constructor(private readonly client: RokuClient, udnArg: string, private readonly onDestroyed: () => void) {
+    const udn = normalizeRokuUdn(udnArg);
+    this.deviceId = `roku.device.${udn}`;
+    this.entityId = `media_player.roku_${udn.replace(/-/g, '_')}`;
+  }
 
-  public async devices(): Promise<shxInterfaces.data.IDeviceDefinition[]> {
-    return RokuMapper.toDevices(await this.client.getSnapshot());
+  public async devices(abortSignalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    return RokuMapper.toDevices(await this.client.getSnapshot(abortSignalArg));
   }
 
   public async entities(): Promise<IIntegrationEntity[]> {
@@ -46,93 +68,42 @@ class RokuRuntime implements IIntegrationRuntime {
   }
 
   public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    if (requestArg.domain === 'remote') {
-      const command = requestArg.data?.command;
-      if (typeof command === 'string') {
-        await this.client.keypress(command);
-        return { success: true };
-      }
-      if (Array.isArray(command)) {
-        for (const item of command) {
-          if (typeof item === 'string') {
-            await this.client.keypress(item);
-          }
-        }
-        return { success: true };
-      }
-      return { success: false, error: 'Roku remote service requires data.command.' };
-    }
-
-    if (requestArg.domain !== 'media_player') {
-      return { success: false, error: `Unsupported Roku service domain: ${requestArg.domain}` };
-    }
-
-    if (requestArg.service === 'turn_on') {
-      await this.client.keypress('PowerOn');
-      return { success: true };
-    }
-    if (requestArg.service === 'turn_off') {
-      await this.client.keypress('PowerOff');
-      return { success: true };
-    }
-    if (requestArg.service === 'play' || requestArg.service === 'pause' || requestArg.service === 'play_pause') {
-      await this.client.keypress('Play');
-      return { success: true };
-    }
-    if (requestArg.service === 'next_track') {
-      await this.client.keypress('Fwd');
-      return { success: true };
-    }
-    if (requestArg.service === 'previous_track') {
-      await this.client.keypress('Rev');
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_up') {
-      await this.client.keypress('VolumeUp');
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_down') {
-      await this.client.keypress('VolumeDown');
-      return { success: true };
-    }
-    if (requestArg.service === 'volume_mute') {
-      await this.client.keypress('VolumeMute');
-      return { success: true };
-    }
-    if (requestArg.service === 'select_source') {
-      const source = requestArg.data?.source;
-      if (source === 'Home') {
-        await this.client.keypress('Home');
-        return { success: true };
-      }
-      if (typeof source === 'string') {
-        const apps = await this.client.getApps();
-        const app = apps.find((appArg) => source === appArg.id || source === appArg.name);
-        if (app) {
-          await this.client.launch(app.id);
-          return { success: true };
-        }
-      }
-      return { success: false, error: 'Roku select_source requires a known source.' };
-    }
-    if (requestArg.service === 'play_media') {
-      const mediaId = requestArg.data?.media_content_id ?? requestArg.data?.uri;
-      const mediaType = requestArg.data?.media_content_type ?? requestArg.data?.media_type;
-      if (typeof mediaId !== 'string' || !mediaId) {
-        return { success: false, error: 'Roku play_media requires data.media_content_id or data.uri.' };
-      }
-      if (mediaType === 'app') {
-        await this.client.launch(mediaId);
-        return { success: true };
-      }
-      await this.client.playUrl(mediaId, mediaType === 'music' || mediaType === 'audio' ? 'audio' : 'video', typeof requestArg.data?.title === 'string' ? requestArg.data.title : undefined);
-      return { success: true };
+    const request = readRokuRecord(requestArg, ['domain', 'service', 'target', 'data']);
+    this.validateTarget(request.target);
+    if (request.domain === 'remote' && request.service === 'send_command') {
+      const data = readRokuRecord(request.data, ['command']);
+      const key = validateRokuKey(data.command);
+      await this.client.keypress(key);
+    } else if (request.domain === 'media_player' && request.service === 'select_source') {
+      const data = readRokuRecord(request.data, ['source']);
+      await this.client.launch(validateRokuAppId(data.source));
+    } else {
+      return { success: false, error: 'Roku supports remote.send_command and media_player.select_source.' };
     }
+    return { success: true, data: { confirmation: 'ecp-http', effectOutcome: 'accepted' } };
+  }
 
-    return { success: false, error: `Unsupported Roku media_player service: ${requestArg.service}` };
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, abortSignalArg?: AbortSignal): Promise<IServiceCallResult> {
+    const request = readRokuRecord(requestArg, ['device', 'feature', 'value']);
+    const device = readRokuRecord(request.device, ['id', 'integrationDomain', 'name', 'protocol', 'manufacturer', 'model', 'online', 'features', 'state', 'metadata', 'room']);
+    if (device.id !== this.deviceId || device.integrationDomain !== this.domain) throw new Error('Roku feature target does not belong to this connection.');
+    const feature = readRokuRecord(request.feature, ['id', 'name', 'capability', 'readable', 'writable', 'unit', 'options', 'metadata']);
+    if (feature.id === 'remote_key') await this.client.keypress(validateRokuKey(request.value), abortSignalArg);
+    else if (feature.id === 'active_app') await this.client.launch(validateRokuAppId(request.value), abortSignalArg);
+    else return { success: false, error: 'Roku writes support remote_key or an installed active_app id.' };
+    return { success: true, data: { confirmation: 'ecp-http', effectOutcome: 'accepted' } };
   }
 
   public async destroy(): Promise<void> {
     await this.client.destroy();
+    this.onDestroyed();
+  }
+
+  private validateTarget(targetArg: unknown): void {
+    const target = readRokuRecord(targetArg, ['deviceId', 'entityId']);
+    if (target.deviceId !== undefined && target.deviceId !== this.deviceId || target.entityId !== undefined && target.entityId !== this.entityId ||
+      target.deviceId === undefined && target.entityId === undefined) {
+      throw new Error('Roku service requires an exact connected device or entity target.');
+    }
   }
 }

package/ts/integrations/roku/roku.discovery.ts

@@ -1,93 +1,90 @@
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
 import type { IRokuManualEntry, IRokuSsdpRecord } from './roku.types.js';
+import { readRokuRecord, validateRokuHost, validateRokuPort } from './roku.validation.js';
+
+const unmatched = (): IDiscoveryMatch => ({ matched: false, confidence: 'low', reason: 'Input is not an admitted Roku endpoint.' });
+
+const readHeader = (headersArg: unknown, keyArg: string): string | undefined => {
+  if (headersArg === undefined) return undefined;
+  if (typeof headersArg !== 'object' || headersArg === null) throw new Error('Invalid Roku SSDP headers.');
+  const fields = Object.getOwnPropertyNames(headersArg).filter((fieldArg) => fieldArg.toLowerCase() === keyArg);
+  const headers = readRokuRecord(headersArg, fields, true);
+  const values = Object.entries(headers).filter(([nameArg]) => nameArg.toLowerCase() === keyArg).map(([, valueArg]) => valueArg);
+  if (values.length > 1 || values.some((valueArg) => typeof valueArg !== 'string')) throw new Error('Ambiguous Roku SSDP header.');
+  const value = values[0];
+  return typeof value === 'string' ? value : undefined;
+};
 
 export class RokuSsdpMatcher implements IDiscoveryMatcher<IRokuSsdpRecord> {
-  public id = 'roku-ssdp-match';
-  public source = 'ssdp' as const;
-  public description = 'Recognize Roku ECP SSDP advertisements.';
+  public readonly id = 'roku-ssdp-match';
+  public readonly source = 'ssdp';
+  public readonly description = 'Admit passive roku:ecp records without fetching their LOCATION.';
 
   public async matches(recordArg: IRokuSsdpRecord): Promise<IDiscoveryMatch> {
-    const st = recordArg.st || recordArg.headers?.st || recordArg.headers?.ST;
-    const usn = recordArg.usn || recordArg.headers?.usn || recordArg.headers?.USN;
-    const location = recordArg.location || recordArg.headers?.location || recordArg.headers?.LOCATION;
-    const manufacturer = recordArg.headers?.manufacturer || recordArg.headers?.MANUFACTURER;
-    const matched = st === 'roku:ecp' || manufacturer === 'Roku' || Boolean(usn?.toLowerCase().includes('roku'));
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'SSDP record is not Roku ECP.' };
-    }
-    const url = location ? new URL(location) : undefined;
-    const id = usn?.replace(/^uuid:/i, '').split('::')[0];
-    return {
-      matched: true,
-      confidence: id ? 'certain' : 'high',
-      reason: 'SSDP record matches Roku ECP metadata.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'ssdp',
-        integrationDomain: 'roku',
-        id,
-        host: url?.hostname,
-        port: url?.port ? Number(url.port) : 8060,
-        manufacturer: 'Roku',
-        model: recordArg.headers?.modelName || recordArg.headers?.MODELNAME,
-        metadata: { st, usn, location },
-      },
-    };
+    try {
+      const record = readRokuRecord(recordArg, ['st', 'usn', 'location', 'headers']);
+      const headerSt = readHeader(record.headers, 'st');
+      const headerUsn = readHeader(record.headers, 'usn');
+      const headerLocation = readHeader(record.headers, 'location');
+      if (record.st !== undefined && headerSt !== undefined && record.st !== headerSt ||
+        record.usn !== undefined && headerUsn !== undefined && record.usn !== headerUsn ||
+        record.location !== undefined && headerLocation !== undefined && record.location !== headerLocation) return unmatched();
+      const st = record.st ?? headerSt;
+      const usn = record.usn ?? headerUsn;
+      const location = record.location ?? headerLocation;
+      if (st !== 'roku:ecp' || typeof usn !== 'string' || typeof location !== 'string') return unmatched();
+      const serial = /^uuid:roku:ecp:([A-Za-z0-9_-]{1,128})$/.exec(usn)?.[1];
+      if (!serial) return unmatched();
+      const url = new URL(location);
+      if (url.protocol !== 'http:' || url.username || url.password || url.pathname !== '/' || url.search || url.hash) return unmatched();
+      const host = validateRokuHost(url.hostname);
+      const port = validateRokuPort(url.port ? Number(url.port) : 80);
+      if (port !== 8060) return unmatched();
+      return {
+        matched: true, confidence: 'high', reason: 'Passive record advertises the Roku ECP service.', normalizedDeviceId: serial,
+        candidate: { source: 'ssdp', integrationDomain: 'roku', id: serial, host, port, manufacturer: 'Roku' },
+      };
+    } catch { return unmatched(); }
   }
 }
 
 export class RokuManualMatcher implements IDiscoveryMatcher<IRokuManualEntry> {
-  public id = 'roku-manual-match';
-  public source = 'manual' as const;
-  public description = 'Recognize manual Roku setup entries.';
+  public readonly id = 'roku-manual-match';
+  public readonly source = 'manual';
+  public readonly description = 'Admit explicitly selected Roku manual entries.';
 
   public async matches(inputArg: IRokuManualEntry): Promise<IDiscoveryMatch> {
-    const matched = Boolean(inputArg.host || inputArg.model?.toLowerCase().includes('roku') || inputArg.metadata?.roku);
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'Manual entry does not contain Roku setup hints.' };
-    }
-    return {
-      matched: true,
-      confidence: inputArg.host ? 'high' : 'medium',
-      reason: 'Manual entry can start Roku setup.',
-      normalizedDeviceId: inputArg.id,
-      candidate: {
-        source: 'manual',
-        integrationDomain: 'roku',
-        id: inputArg.id,
-        host: inputArg.host,
-        port: inputArg.port || 8060,
-        name: inputArg.name,
-        manufacturer: 'Roku',
-        model: inputArg.model,
-        metadata: inputArg.metadata,
-      },
-    };
+    try {
+      const input = readRokuRecord(inputArg, ['integrationDomain', 'host', 'port', 'id', 'name']);
+      if (input.integrationDomain !== 'roku') return unmatched();
+      if (input.id !== undefined && typeof input.id !== 'string' || input.name !== undefined && typeof input.name !== 'string') return unmatched();
+      return new RokuCandidateValidator().validate({ source: 'manual', integrationDomain: 'roku', host: validateRokuHost(input.host), port: validateRokuPort(input.port), id: input.id, name: input.name });
+    } catch { return unmatched(); }
   }
 }
 
 export class RokuCandidateValidator implements IDiscoveryValidator {
-  public id = 'roku-candidate-validator';
-  public description = 'Validate Roku ECP candidate metadata.';
+  public readonly id = 'roku-candidate-validator';
+  public readonly description = 'Normalize Roku candidate fields without retaining arbitrary discovery metadata.';
 
   public async validate(candidateArg: IDiscoveryCandidate): Promise<IDiscoveryMatch> {
-    const manufacturer = candidateArg.manufacturer?.toLowerCase() || '';
-    const model = candidateArg.model?.toLowerCase() || '';
-    const matched = candidateArg.integrationDomain === 'roku' || manufacturer === 'roku' || model.includes('roku');
-    return {
-      matched,
-      confidence: matched && candidateArg.host ? 'high' : matched ? 'medium' : 'low',
-      reason: matched ? 'Candidate has Roku metadata.' : 'Candidate is not Roku.',
-      candidate: matched ? candidateArg : undefined,
-      normalizedDeviceId: candidateArg.id,
-    };
+    try {
+      const input = readRokuRecord(candidateArg, ['source', 'integrationDomain', 'id', 'host', 'port', 'name', 'manufacturer', 'model', 'serialNumber', 'macAddress', 'metadata']);
+      if (input.integrationDomain !== 'roku' || input.source !== 'manual' && input.source !== 'ssdp') return unmatched();
+      const candidate: IDiscoveryCandidate = { source: input.source === 'manual' ? 'manual' : 'ssdp', integrationDomain: 'roku', host: validateRokuHost(input.host), port: validateRokuPort(input.port), manufacturer: 'Roku' };
+      if (input.id !== undefined) {
+        if (typeof input.id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(input.id)) return unmatched();
+        candidate.id = input.id;
+      }
+      if (input.name !== undefined) {
+        if (typeof input.name !== 'string' || input.name.length > 128 || /[\u0000-\u001f]/.test(input.name)) return unmatched();
+        candidate.name = input.name;
+      }
+      return { matched: true, confidence: 'high', reason: 'Candidate has an explicit Roku domain and safe local endpoint.', candidate, normalizedDeviceId: candidate.id };
+    } catch { return unmatched(); }
   }
 }
 
-export const createRokuDiscoveryDescriptor = (): DiscoveryDescriptor => {
-  return new DiscoveryDescriptor({ integrationDomain: 'roku', displayName: 'Roku' })
-    .addMatcher(new RokuSsdpMatcher())
-    .addMatcher(new RokuManualMatcher())
-    .addValidator(new RokuCandidateValidator());
-};
+export const createRokuDiscoveryDescriptor = (): DiscoveryDescriptor => new DiscoveryDescriptor({ integrationDomain: 'roku', displayName: 'Roku' })
+  .addMatcher(new RokuSsdpMatcher()).addMatcher(new RokuManualMatcher()).addValidator(new RokuCandidateValidator());

package/ts/integrations/roku/roku.mapper.ts

@@ -1,84 +1,49 @@
 import * as plugins from '../../plugins.js';
 import type { IIntegrationEntity } from '../../core/types.js';
 import type { IRokuSnapshot } from './roku.types.js';
+import { normalizeRokuUdn } from './roku.validation.js';
 
 export class RokuMapper {
   public static toDevices(snapshotArg: IRokuSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
-    const updatedAt = new Date().toISOString();
     return [{
-      id: this.deviceId(snapshotArg),
-      integrationDomain: 'roku',
-      name: this.deviceName(snapshotArg),
-      protocol: 'http',
-      manufacturer: snapshotArg.deviceInfo.vendorName || 'Roku',
-      model: snapshotArg.deviceInfo.modelName || snapshotArg.deviceInfo.modelNumber,
+      id: this.deviceId(snapshotArg), integrationDomain: 'roku', name: this.deviceName(snapshotArg), protocol: 'http',
+      manufacturer: snapshotArg.deviceInfo.vendorName ?? 'Roku', model: snapshotArg.deviceInfo.modelName ?? snapshotArg.deviceInfo.modelNumber,
       online: true,
       features: [
-        { id: 'power', capability: 'media', name: 'Power', readable: true, writable: true },
+        { id: 'power_mode', capability: 'media', name: 'Reported power mode', readable: true, writable: false },
         { id: 'active_app', capability: 'media', name: 'Active app', readable: true, writable: true },
         { id: 'remote_key', capability: 'media', name: 'Remote key', readable: false, writable: true },
       ],
       state: [
-        { featureId: 'power', value: this.powerState(snapshotArg), updatedAt },
-        { featureId: 'active_app', value: snapshotArg.activeApp?.name || null, updatedAt },
+        { featureId: 'power_mode', value: snapshotArg.deviceInfo.powerMode ?? null, updatedAt: snapshotArg.observedAt },
+        { featureId: 'active_app', value: snapshotArg.activeApp.id ?? null, updatedAt: snapshotArg.observedAt },
       ],
       metadata: {
-        serialNumber: snapshotArg.deviceInfo.serialNumber,
-        deviceId: snapshotArg.deviceInfo.deviceId,
-        deviceType: snapshotArg.deviceInfo.deviceType,
-        softwareVersion: snapshotArg.deviceInfo.softwareVersion,
-        apps: snapshotArg.apps.map((appArg) => ({ id: appArg.id, name: appArg.name })),
+        udn: snapshotArg.deviceInfo.udn, serialNumber: snapshotArg.deviceInfo.serialNumber, deviceId: snapshotArg.deviceInfo.deviceId,
+        softwareVersion: snapshotArg.deviceInfo.softwareVersion, activeAppName: snapshotArg.activeApp.name,
+        apps: snapshotArg.apps.map((appArg) => ({ id: appArg.id, name: appArg.name, type: appArg.type })),
       },
     }];
   }
 
   public static toEntities(snapshotArg: IRokuSnapshot): IIntegrationEntity[] {
+    const udn = normalizeRokuUdn(snapshotArg.deviceInfo.udn);
     return [{
-      id: `media_player.${this.slug(this.deviceName(snapshotArg))}`,
-      uniqueId: `roku_${this.slug(snapshotArg.deviceInfo.deviceId || snapshotArg.deviceInfo.serialNumber || this.deviceName(snapshotArg))}`,
-      integrationDomain: 'roku',
-      deviceId: this.deviceId(snapshotArg),
-      platform: 'media_player',
-      name: this.deviceName(snapshotArg),
-      state: this.mediaState(snapshotArg),
+      id: `media_player.roku_${udn.replace(/-/g, '_')}`, uniqueId: `roku_${udn}`, integrationDomain: 'roku',
+      deviceId: this.deviceId(snapshotArg), platform: 'media_player', name: this.deviceName(snapshotArg),
+      state: snapshotArg.activeApp.name,
       attributes: {
-        source: snapshotArg.activeApp?.name,
-        appId: snapshotArg.activeApp?.id,
-        sourceList: ['Home', ...snapshotArg.apps.map((appArg) => appArg.name)],
-        powerMode: snapshotArg.deviceInfo.powerMode,
+        appId: snapshotArg.activeApp.id, source: snapshotArg.activeApp.name,
+        sources: snapshotArg.apps.map((appArg) => ({ id: appArg.id, name: appArg.name })),
+        powerMode: snapshotArg.deviceInfo.powerMode, observedAt: snapshotArg.observedAt,
       },
       available: true,
     }];
   }
 
-  private static mediaState(snapshotArg: IRokuSnapshot): string {
-    if (this.powerState(snapshotArg) === 'off') {
-      return 'off';
-    }
-    const activeName = snapshotArg.activeApp?.name;
-    if (!activeName || activeName === 'Power Saver' || activeName === 'Roku') {
-      return 'idle';
-    }
-    return 'on';
-  }
-
-  private static powerState(snapshotArg: IRokuSnapshot): string {
-    const powerMode = snapshotArg.deviceInfo.powerMode?.toLowerCase() || '';
-    if (powerMode.includes('off') || powerMode.includes('standby') || powerMode.includes('suspend')) {
-      return 'off';
-    }
-    return 'on';
-  }
-
-  private static deviceId(snapshotArg: IRokuSnapshot): string {
-    return `roku.device.${this.slug(snapshotArg.deviceInfo.deviceId || snapshotArg.deviceInfo.serialNumber || this.deviceName(snapshotArg))}`;
-  }
+  private static deviceId(snapshotArg: IRokuSnapshot): string { return `roku.device.${normalizeRokuUdn(snapshotArg.deviceInfo.udn)}`; }
 
   private static deviceName(snapshotArg: IRokuSnapshot): string {
     return snapshotArg.deviceInfo.userDeviceName || snapshotArg.deviceInfo.friendlyDeviceName || snapshotArg.deviceInfo.modelName || 'Roku';
   }
-
-  private static slug(valueArg: string): string {
-    return valueArg.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'roku';
-  }
 }

package/ts/integrations/roku/roku.types.ts

@@ -1,13 +1,16 @@
 export interface IRokuConfig {
-  host?: string;
-  port?: number;
-  deviceInfo?: IRokuDeviceInfo;
-  apps?: IRokuApp[];
-  activeApp?: IRokuApp;
-  playMediaAppId?: string;
+  readonly host: string;
+  readonly port?: number;
+  readonly udn: string;
+  readonly requestTimeoutMs?: number;
+}
+
+export interface IRokuClientOptions {
+  abortSignal?: AbortSignal;
 }
 
 export interface IRokuDeviceInfo {
+  udn: string;
   serialNumber?: string;
   deviceId?: string;
   vendorName?: string;
@@ -15,10 +18,10 @@ export interface IRokuDeviceInfo {
   modelNumber?: string;
   friendlyDeviceName?: string;
   userDeviceName?: string;
-  deviceType?: string;
   softwareVersion?: string;
   powerMode?: string;
-  supportsSuspend?: boolean;
+  isTv?: boolean;
+  supportsAudioVolumeControl?: boolean;
 }
 
 export interface IRokuApp {
@@ -28,10 +31,18 @@ export interface IRokuApp {
   version?: string;
 }
 
+export interface IRokuActiveApp {
+  id?: string;
+  name: string;
+  type?: string;
+  version?: string;
+}
+
 export interface IRokuSnapshot {
   deviceInfo: IRokuDeviceInfo;
   apps: IRokuApp[];
-  activeApp?: IRokuApp;
+  activeApp: IRokuActiveApp;
+  observedAt: string;
 }
 
 export interface IRokuSsdpRecord {
@@ -42,14 +53,15 @@ export interface IRokuSsdpRecord {
 }
 
 export interface IRokuManualEntry {
+  integrationDomain?: string;
   host?: string;
   port?: number;
   id?: string;
   name?: string;
-  model?: string;
-  metadata?: Record<string, unknown>;
 }
 
+export type TRokuEffectOutcome = 'not-sent' | 'rejected' | 'indeterminate';
+
 export type TRokuKeypress =
   | 'Home'
   | 'Rev'
@@ -66,9 +78,6 @@ export type TRokuKeypress =
   | 'Backspace'
   | 'Search'
   | 'Enter'
-  | 'PowerOn'
-  | 'PowerOff'
-  | 'Power'
   | 'VolumeUp'
   | 'VolumeDown'
   | 'VolumeMute';