@smarthome.exchange/integrations 0.2.0 → 1.0.0

package/ts/integrations/samsungtv/samsungtv.discovery.ts

@@ -1,190 +1,126 @@
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
 import type { ISamsungtvManualEntry, ISamsungtvMdnsRecord, ISamsungtvSsdpRecord } from './samsungtv.types.js';
-
-const remoteControlReceiver = 'urn:samsung.com:device:RemoteControlReceiver:1';
-const mainTvAgent = 'urn:samsung.com:service:MainTVAgent2:1';
-const renderingControl = 'urn:schemas-upnp-org:service:RenderingControl:1';
+import { samsungtvDeviceId, samsungtvObject, samsungtvOrigin } from './samsungtv.validation.js';
+
+const services = new Set(['urn:samsung.com:device:RemoteControlReceiver:1', 'urn:samsung.com:service:MainTVAgent2:1']);
+const missed = (reasonArg: string): IDiscoveryMatch => ({ matched: false, confidence: 'low', reason: reasonArg });
+const text = (valueArg: unknown): string | undefined =>
+  typeof valueArg === 'string' && valueArg.length > 0 && valueArg.length <= 2048 && !/[\p{Cc}\p{Cs}]/u.test(valueArg) ? valueArg : undefined;
+const identity = (valueArg: unknown): string | undefined => {
+  try { return samsungtvDeviceId(valueArg); } catch { return undefined; }
+};
+const recordValue = (recordArg: Record<string, unknown>, namesArg: readonly string[]): string | undefined => {
+  const maps = [recordArg];
+  for (const key of ['headers', 'upnp']) {
+    if (recordArg[key] !== undefined) maps.push(samsungtvObject(recordArg[key], 'Samsung TV discovery metadata'));
+  }
+  for (const map of maps) {
+    for (const [key, value] of Object.entries(map)) {
+      if (namesArg.includes(key.toLowerCase())) {
+        const result = text(value);
+        if (result) return result;
+      }
+    }
+  }
+  return undefined;
+};
+const location = (valueArg: unknown): URL | undefined => {
+  const value = text(valueArg);
+  if (!value) return undefined;
+  try {
+    const url = new URL(value);
+    return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash ? url : undefined;
+  } catch { return undefined; }
+};
+const publicHints = (metadataArg: unknown): Record<string, string> => {
+  const hints: Record<string, string> = {};
+  if (metadataArg === undefined) return hints;
+  const metadata = samsungtvObject(metadataArg, 'Samsung TV candidate metadata');
+  if (metadata.expectedDeviceId !== undefined) hints.expectedDeviceId = samsungtvDeviceId(metadata.expectedDeviceId);
+  if (metadata.httpOrigin !== undefined) hints.httpOrigin = samsungtvOrigin(metadata.httpOrigin, ['http:', 'https:']);
+  if (metadata.websocketOrigin !== undefined) hints.websocketOrigin = samsungtvOrigin(metadata.websocketOrigin, ['wss:']);
+  return hints;
+};
 
 export class SamsungtvSsdpMatcher implements IDiscoveryMatcher<ISamsungtvSsdpRecord> {
-  public id = 'samsungtv-ssdp-match';
-  public source = 'ssdp' as const;
-  public description = 'Recognize Samsung TV SSDP and UPnP advertisements.';
-
+  public readonly id = 'samsungtv-ssdp-match';
+  public readonly source = 'ssdp' as const;
+  public readonly description = 'Recognize public Samsung TV SSDP hints without treating an advertisement as verified identity.';
   public async matches(recordArg: ISamsungtvSsdpRecord): Promise<IDiscoveryMatch> {
-    const st = readRecordValue(recordArg, 'st', 'ST', 'ssdp_st') || recordArg.ssdp_st;
-    const usn = readRecordValue(recordArg, 'usn', 'USN', 'udn', 'UDN', 'ssdp_usn') || recordArg.ssdp_usn;
-    const location = readRecordValue(recordArg, 'location', 'LOCATION', 'ssdp_location') || recordArg.ssdp_location;
-    const manufacturer = readRecordValue(recordArg, 'manufacturer', 'MANUFACTURER', 'upnp:manufacturer') || '';
-    const model = readRecordValue(recordArg, 'modelName', 'model_name', 'model', 'upnp:modelName');
-    const matchedByService = st === remoteControlReceiver || st === mainTvAgent;
-    const matchedByRendering = st === renderingControl && startsSamsung(manufacturer);
-    if (!matchedByService && !matchedByRendering) {
-      return { matched: false, confidence: 'low', reason: 'SSDP record is not a Samsung TV advertisement.' };
-    }
-
-    const url = safeUrl(location);
-    const id = stripUuid(usn || readRecordValue(recordArg, 'udn', 'UDN'));
-    const metadata: Record<string, unknown> = { st, usn, location };
-    if (st === renderingControl && location) {
-      metadata.ssdpRenderingControlLocation = location;
-    }
-    if (st === mainTvAgent && location) {
-      metadata.ssdpMainTvAgentLocation = location;
-    }
-
-    return {
-      matched: true,
-      confidence: id ? 'certain' : 'high',
-      reason: 'SSDP record matches Samsung TV metadata.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'ssdp',
-        integrationDomain: 'samsungtv',
-        id,
-        host: url?.hostname,
-        port: 8001,
-        manufacturer: manufacturer || 'Samsung',
-        model,
-        metadata,
-      },
-    };
+    try {
+      const record = samsungtvObject(recordArg, 'Samsung TV SSDP record');
+      const service = recordValue(record, ['st', 'ssdp_st']);
+      const manufacturer = recordValue(record, ['manufacturer', 'upnp:manufacturer']);
+      if (!service || (!services.has(service) && !(service === 'urn:schemas-upnp-org:service:RenderingControl:1' && manufacturer?.toLowerCase().startsWith('samsung')))) {
+        return missed('SSDP record is not a Samsung TV advertisement.');
+      }
+      const url = location(recordValue(record, ['location', 'ssdp_location']));
+      if (!url) return missed('Samsung TV SSDP location is invalid.');
+      const id = identity(recordValue(record, ['usn', 'udn', 'ssdp_usn'])?.split('::')[0]);
+      return { matched: true, confidence: 'medium', reason: 'Samsung TV advertisement requires explicit UUID and endpoint confirmation.', normalizedDeviceId: id,
+        candidate: { source: 'ssdp', integrationDomain: 'samsungtv', id, host: url.hostname,
+          manufacturer: 'Samsung', model: recordValue(record, ['modelname', 'model_name', 'model', 'upnp:modelname']),
+          metadata: { httpOrigin: url.origin, ...(id ? { expectedDeviceId: id } : {}) } } };
+    } catch { return missed('Samsung TV SSDP record is invalid.'); }
   }
 }
 
 export class SamsungtvMdnsMatcher implements IDiscoveryMatcher<ISamsungtvMdnsRecord> {
-  public id = 'samsungtv-mdns-match';
-  public source = 'mdns' as const;
-  public description = 'Recognize Samsung TV mDNS AirPlay advertisements.';
-
+  public readonly id = 'samsungtv-mdns-match';
+  public readonly source = 'mdns' as const;
+  public readonly description = 'Recognize public Samsung AirPlay hints without substituting MAC addresses for TV UUIDs.';
   public async matches(recordArg: ISamsungtvMdnsRecord): Promise<IDiscoveryMatch> {
-    const txt = { ...(recordArg.txt ?? {}), ...(recordArg.properties ?? {}) };
-    const type = recordArg.type?.toLowerCase() || '';
-    const manufacturer = txt.manufacturer || txt.Manufacturer || '';
-    const name = recordArg.name || txt.name || txt.friendlyName;
-    const model = txt.model || txt.modelName || txt.modelid;
-    const matched = type === '_airplay._tcp.local.' && startsSamsung(manufacturer);
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'mDNS record is not a Samsung TV AirPlay advertisement.' };
-    }
-
-    const id = txt.deviceid || txt.deviceId || txt.id || name;
-    return {
-      matched: true,
-      confidence: id ? 'certain' : 'high',
-      reason: 'mDNS record matches Samsung TV AirPlay metadata.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'mdns',
-        integrationDomain: 'samsungtv',
-        id,
-        host: recordArg.host,
-        port: 8001,
-        name,
-        manufacturer: 'Samsung',
-        model,
-        macAddress: txt.deviceid || txt.deviceId,
-        metadata: { mdnsType: recordArg.type, mdnsName: recordArg.name, mdnsPort: recordArg.port, txt },
-      },
-    };
+    try {
+      const record = samsungtvObject(recordArg, 'Samsung TV mDNS record');
+      const txt = record.txt === undefined ? {} : samsungtvObject(record.txt, 'Samsung TV mDNS TXT');
+      const properties = record.properties === undefined ? {} : samsungtvObject(record.properties, 'Samsung TV mDNS properties');
+      const manufacturer = text(properties.manufacturer ?? txt.manufacturer ?? properties.Manufacturer ?? txt.Manufacturer);
+      if (record.type !== '_airplay._tcp.local.' || !manufacturer?.toLowerCase().startsWith('samsung')) return missed('mDNS record is not a Samsung TV AirPlay advertisement.');
+      return { matched: true, confidence: 'low', reason: 'AirPlay advertisement is a setup hint; an exact TV UUID and verified WSS endpoint are required.',
+        candidate: { source: 'mdns', integrationDomain: 'samsungtv', host: text(record.host), name: text(record.name),
+          manufacturer: 'Samsung', model: text(properties.model ?? txt.model), metadata: {} } };
+    } catch { return missed('Samsung TV mDNS record is invalid.'); }
   }
 }
 
 export class SamsungtvManualMatcher implements IDiscoveryMatcher<ISamsungtvManualEntry> {
-  public id = 'samsungtv-manual-match';
-  public source = 'manual' as const;
-  public description = 'Recognize manual Samsung TV setup entries.';
-
+  public readonly id = 'samsungtv-manual-match';
+  public readonly source = 'manual' as const;
+  public readonly description = 'Accept bounded public manual setup hints without copying credential-shaped metadata.';
   public async matches(inputArg: ISamsungtvManualEntry): Promise<IDiscoveryMatch> {
-    const manufacturer = inputArg.manufacturer?.toLowerCase() || '';
-    const model = inputArg.model?.toLowerCase() || '';
-    const matched = Boolean(inputArg.host || startsSamsung(manufacturer) || model.includes('samsung') || model.includes('tizen') || inputArg.metadata?.samsungtv);
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'Manual entry does not contain Samsung TV setup hints.' };
-    }
-
-    return {
-      matched: true,
-      confidence: inputArg.host ? 'high' : 'medium',
-      reason: 'Manual entry can start Samsung TV setup.',
-      normalizedDeviceId: inputArg.id || inputArg.macAddress,
-      candidate: {
-        source: 'manual',
-        integrationDomain: 'samsungtv',
-        id: inputArg.id || inputArg.macAddress,
-        host: inputArg.host,
-        port: inputArg.port || 8001,
-        name: inputArg.name,
-        manufacturer: inputArg.manufacturer || 'Samsung',
-        model: inputArg.model,
-        macAddress: inputArg.macAddress,
-        metadata: { ...(inputArg.metadata ?? {}), token: inputArg.token },
-      },
-    };
+    try {
+      const input = samsungtvObject(inputArg, 'Samsung TV manual record');
+      if (!text(input.host) && !text(input.manufacturer)?.toLowerCase().startsWith('samsung')) return missed('Manual entry has no Samsung TV setup hints.');
+      const metadata = publicHints(input.metadata);
+      const id = identity(input.id) ?? metadata.expectedDeviceId;
+      return { matched: true, confidence: 'medium', reason: 'Manual entry requires live UUID and capability verification.', normalizedDeviceId: id,
+        candidate: { source: 'manual', integrationDomain: 'samsungtv', id, host: text(input.host), name: text(input.name), model: text(input.model), manufacturer: 'Samsung', metadata } };
+    } catch { return missed('Samsung TV manual entry is invalid.'); }
   }
 }
 
 export class SamsungtvCandidateValidator implements IDiscoveryValidator {
-  public id = 'samsungtv-candidate-validator';
-  public description = 'Validate Samsung TV discovery candidates.';
-
+  public readonly id = 'samsungtv-candidate-validator';
+  public readonly description = 'Require public exact-UUID and explicit REST/WSS origin proposals; live setup performs identity verification.';
   public async validate(candidateArg: IDiscoveryCandidate): Promise<IDiscoveryMatch> {
-    const manufacturer = candidateArg.manufacturer?.toLowerCase() || '';
-    const model = candidateArg.model?.toLowerCase() || '';
-    const matched = candidateArg.integrationDomain === 'samsungtv'
-      || startsSamsung(manufacturer)
-      || model.includes('samsung')
-      || model.includes('tizen')
-      || Boolean(candidateArg.metadata?.samsungtv);
-    return {
-      matched,
-      confidence: matched && candidateArg.host ? 'high' : matched ? 'medium' : 'low',
-      reason: matched ? 'Candidate has Samsung TV metadata.' : 'Candidate is not Samsung TV.',
-      candidate: matched ? candidateArg : undefined,
-      normalizedDeviceId: candidateArg.id || candidateArg.macAddress,
-    };
+    try {
+      const candidate = samsungtvObject(candidateArg, 'Samsung TV candidate');
+      if (candidate.integrationDomain !== 'samsungtv') return missed('Candidate is not Samsung TV.');
+      const metadata = publicHints(candidate.metadata);
+      const id = identity(candidate.id) ?? metadata.expectedDeviceId;
+      if (!id || !metadata.httpOrigin || !metadata.websocketOrigin || new URL(metadata.httpOrigin).hostname !== new URL(metadata.websocketOrigin).hostname) {
+        return missed('Samsung TV candidate requires an exact UUID and same-host explicit REST/WSS origins.');
+      }
+      if (metadata.expectedDeviceId && metadata.expectedDeviceId !== id) return missed('Samsung TV candidate identities conflict.');
+      return { matched: true, confidence: 'medium', reason: 'Public setup proposal is complete; live UUID and WSS trust verification remain required.', normalizedDeviceId: id,
+        candidate: { source: candidateArg.source, integrationDomain: 'samsungtv', id, host: new URL(metadata.httpOrigin).hostname,
+          name: text(candidate.name), manufacturer: 'Samsung', model: text(candidate.model), metadata: { ...metadata, expectedDeviceId: id } } };
+    } catch { return missed('Samsung TV candidate is invalid.'); }
   }
 }
 
-export const createSamsungtvDiscoveryDescriptor = (): DiscoveryDescriptor => {
-  return new DiscoveryDescriptor({ integrationDomain: 'samsungtv', displayName: 'Samsung Smart TV' })
-    .addMatcher(new SamsungtvSsdpMatcher())
-    .addMatcher(new SamsungtvMdnsMatcher())
-    .addMatcher(new SamsungtvManualMatcher())
+export const createSamsungtvDiscoveryDescriptor = (): DiscoveryDescriptor =>
+  new DiscoveryDescriptor({ integrationDomain: 'samsungtv', displayName: 'Samsung Smart TV' })
+    .addMatcher(new SamsungtvSsdpMatcher()).addMatcher(new SamsungtvMdnsMatcher()).addMatcher(new SamsungtvManualMatcher())
     .addValidator(new SamsungtvCandidateValidator());
-};
-
-const startsSamsung = (valueArg: string | undefined): boolean => Boolean(valueArg?.toLowerCase().startsWith('samsung'));
-
-const stripUuid = (valueArg?: string): string | undefined => {
-  if (!valueArg) {
-    return undefined;
-  }
-  return valueArg.replace(/^uuid:/i, '').split('::')[0];
-};
-
-const safeUrl = (valueArg?: string): URL | undefined => {
-  if (!valueArg) {
-    return undefined;
-  }
-  try {
-    return new URL(valueArg);
-  } catch {
-    return undefined;
-  }
-};
-
-const readRecordValue = (recordArg: ISamsungtvSsdpRecord, ...keysArg: string[]): string | undefined => {
-  const maps = [recordArg.headers, recordArg.upnp, recordArg as Record<string, string | undefined>].filter(Boolean) as Array<Record<string, string | undefined>>;
-  for (const key of keysArg) {
-    const lowerKey = key.toLowerCase();
-    for (const map of maps) {
-      for (const [candidateKey, value] of Object.entries(map)) {
-        if (candidateKey.toLowerCase() === lowerKey && value) {
-          return value;
-        }
-      }
-    }
-  }
-  return undefined;
-};

package/ts/integrations/samsungtv/samsungtv.mapper.ts

@@ -1,142 +1,35 @@
 import * as plugins from '../../plugins.js';
-import type { IIntegrationEntity, IIntegrationEvent } from '../../core/types.js';
-import type { ISamsungtvEvent, ISamsungtvSnapshot, ISamsungtvState } from './samsungtv.types.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { ISamsungtvSnapshot } from './samsungtv.types.js';
 
 export class SamsungtvMapper {
+  public static deviceId(snapshotArg: ISamsungtvSnapshot): string {
+    return `samsungtv:${encodeURIComponent(snapshotArg.homeId)}:${snapshotArg.device.deviceId}`;
+  }
+
   public static toDevices(snapshotArg: ISamsungtvSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
-    const updatedAt = new Date().toISOString();
-    const state = this.state(snapshotArg);
+    const device = snapshotArg.device;
     return [{
-      id: this.deviceId(snapshotArg),
-      integrationDomain: 'samsungtv',
-      name: this.deviceName(snapshotArg),
-      protocol: 'http',
-      manufacturer: snapshotArg.deviceInfo.device?.manufacturer || 'Samsung',
-      model: snapshotArg.deviceInfo.device?.modelName || snapshotArg.deviceInfo.device?.modelNumber,
-      online: state.power !== 'off',
+      id: this.deviceId(snapshotArg), integrationDomain: 'samsungtv', name: device.name,
+      protocol: 'http', manufacturer: 'Samsung', model: device.model, online: snapshotArg.remoteConnected,
       features: [
-        { id: 'power', capability: 'media', name: 'Power', readable: true, writable: true },
-        { id: 'playback', capability: 'media', name: 'Playback', readable: true, writable: true },
-        { id: 'source', capability: 'media', name: 'Source', readable: true, writable: true },
-        { id: 'volume', capability: 'media', name: 'Volume', readable: true, writable: true, unit: '%' },
-        { id: 'muted', capability: 'media', name: 'Muted', readable: true, writable: true },
-        { id: 'remote_key', capability: 'media', name: 'Remote key', readable: false, writable: true },
+        { id: 'power', capability: 'media', name: 'Observed power', readable: true, writable: false },
+        { id: 'remote_key', capability: 'media', name: 'Remote key', readable: false, writable: snapshotArg.remoteConnected && device.supportedKeys.length > 0 },
       ],
-      state: [
-        { featureId: 'power', value: state.power, updatedAt },
-        { featureId: 'playback', value: state.playback, updatedAt },
-        { featureId: 'source', value: state.source ?? null, updatedAt },
-        { featureId: 'volume', value: state.volumeLevel ?? null, updatedAt },
-        { featureId: 'muted', value: state.muted ?? null, updatedAt },
-      ],
-      metadata: {
-        id: snapshotArg.deviceInfo.id,
-        udn: snapshotArg.deviceInfo.device?.udn,
-        serialNumber: snapshotArg.deviceInfo.device?.serialNumber,
-        macAddress: snapshotArg.deviceInfo.device?.wifiMac,
-        frameTvSupport: snapshotArg.deviceInfo.device?.FrameTVSupport,
-        apps: snapshotArg.apps.map((appArg) => ({ id: appArg.id, name: appArg.name, type: appArg.type })),
-      },
+      state: [{ featureId: 'power', value: device.power, updatedAt: device.observedAt }],
+      metadata: { deviceId: device.deviceId, observedAt: device.observedAt, supportedKeys: [...device.supportedKeys],
+        remoteAvailable: device.remoteAvailable, tokenAuthentication: device.tokenAuthentication },
     }];
   }
 
   public static toEntities(snapshotArg: ISamsungtvSnapshot): IIntegrationEntity[] {
-    const state = this.state(snapshotArg);
+    const deviceId = this.deviceId(snapshotArg);
     return [{
-      id: `media_player.${this.slug(this.deviceName(snapshotArg))}`,
-      uniqueId: `samsungtv_${this.slug(this.identity(snapshotArg))}`,
-      integrationDomain: 'samsungtv',
-      deviceId: this.deviceId(snapshotArg),
-      platform: 'media_player',
-      name: this.deviceName(snapshotArg),
-      state: this.mediaState(state),
-      attributes: {
-        source: state.source,
-        appId: state.appId,
-        appName: state.appName,
-        sourceList: this.sourceList(snapshotArg),
-        volumeLevel: state.volumeLevel,
-        isVolumeMuted: state.muted,
-        mediaTitle: state.mediaTitle,
-        model: snapshotArg.deviceInfo.device?.modelName || snapshotArg.deviceInfo.device?.modelNumber,
-      },
-      available: state.power !== 'off',
+      id: `${deviceId}:media_player`, uniqueId: deviceId, integrationDomain: 'samsungtv', deviceId,
+      platform: 'media_player', name: snapshotArg.device.name, state: snapshotArg.device.power,
+      attributes: { observedAt: snapshotArg.device.observedAt, supportedKeys: [...snapshotArg.device.supportedKeys],
+        remoteAvailable: snapshotArg.device.remoteAvailable, model: snapshotArg.device.model },
+      available: snapshotArg.remoteConnected,
     }];
   }
-
-  public static toIntegrationEvent(eventArg: ISamsungtvEvent): IIntegrationEvent {
-    return {
-      type: eventArg.type === 'error' ? 'error' : 'state_changed',
-      integrationDomain: 'samsungtv',
-      data: eventArg,
-      timestamp: eventArg.timestamp,
-    };
-  }
-
-  public static deviceId(snapshotArg: ISamsungtvSnapshot): string {
-    return `samsungtv.device.${this.slug(this.identity(snapshotArg))}`;
-  }
-
-  private static state(snapshotArg: ISamsungtvSnapshot): Required<Pick<ISamsungtvState, 'power' | 'playback'>> & ISamsungtvState {
-    const power = snapshotArg.state?.power ?? this.powerFromDeviceInfo(snapshotArg);
-    const appId = snapshotArg.state?.appId ?? snapshotArg.activeApp?.id;
-    const appName = snapshotArg.state?.appName ?? snapshotArg.activeApp?.name;
-    const source = snapshotArg.state?.source ?? appName;
-    return {
-      ...(snapshotArg.state ?? {}),
-      power,
-      playback: snapshotArg.state?.playback ?? (power === 'off' ? 'off' : 'idle'),
-      appId,
-      appName,
-      source,
-    };
-  }
-
-  private static mediaState(stateArg: Required<Pick<ISamsungtvState, 'power' | 'playback'>> & ISamsungtvState): string {
-    if (stateArg.power === 'off') {
-      return 'off';
-    }
-    if (stateArg.playback === 'playing') {
-      return 'playing';
-    }
-    if (stateArg.playback === 'paused') {
-      return 'paused';
-    }
-    if (stateArg.power === 'unknown') {
-      return 'unknown';
-    }
-    return stateArg.source ? 'on' : 'idle';
-  }
-
-  private static sourceList(snapshotArg: ISamsungtvSnapshot): string[] {
-    return [...new Set(['TV', 'HDMI', ...snapshotArg.apps.map((appArg) => appArg.name)])];
-  }
-
-  private static powerFromDeviceInfo(snapshotArg: ISamsungtvSnapshot): 'on' | 'off' | 'unknown' {
-    const value = String(snapshotArg.deviceInfo.device?.PowerState || '').toLowerCase();
-    if (value === 'on') {
-      return 'on';
-    }
-    if (value.includes('off') || value.includes('standby') || value.includes('sleep')) {
-      return 'off';
-    }
-    return 'unknown';
-  }
-
-  private static deviceName(snapshotArg: ISamsungtvSnapshot): string {
-    const name = snapshotArg.deviceInfo.device?.name || snapshotArg.deviceInfo.device?.modelName || 'Samsung Smart TV';
-    return name.replace(/^\[TV\]\s*/i, '') || 'Samsung Smart TV';
-  }
-
-  private static identity(snapshotArg: ISamsungtvSnapshot): string {
-    return snapshotArg.deviceInfo.id
-      || snapshotArg.deviceInfo.device?.udn
-      || snapshotArg.deviceInfo.device?.wifiMac
-      || snapshotArg.deviceInfo.device?.serialNumber
-      || this.deviceName(snapshotArg);
-  }
-
-  private static slug(valueArg: string): string {
-    return valueArg.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'samsungtv';
-  }
 }

package/ts/integrations/samsungtv/samsungtv.types.ts

@@ -1,109 +1,33 @@
-export type TSamsungtvProtocolMethod = 'websocket' | 'legacy' | 'encrypted';
-
-export type TSamsungtvPowerState = 'on' | 'off' | 'unknown';
-
-export type TSamsungtvRemoteKey = `KEY_${string}` | string;
-
-export type TSamsungtvCommandAction = 'Click' | 'Press' | 'Release';
+import type * as plugins from '../../plugins.js';
+import type { IConfigEncryptionKeyProvider } from '../../core/classes.configstore.js';
 
 export interface ISamsungtvConfig {
-  host?: string;
-  port?: number;
-  token?: string;
+  homeId: string;
+  httpOrigin: string;
+  websocketOrigin: string;
+  expectedDeviceId: string;
+  pairingMode: 'existing' | 'prompt';
   name?: string;
-  model?: string;
-  manufacturer?: string;
-  macAddress?: string;
-  method?: TSamsungtvProtocolMethod;
-  sessionId?: string;
-  deviceInfo?: ISamsungtvDeviceInfoResponse;
-  state?: ISamsungtvState;
-  apps?: ISamsungtvApp[];
-  activeApp?: ISamsungtvApp;
-  snapshot?: ISamsungtvSnapshot;
-  ssdpRenderingControlLocation?: string;
-  ssdpMainTvAgentLocation?: string;
-  websocketName?: string;
-  keyPressDelayMs?: number;
-  connectTimeoutMs?: number;
+  certificateAuthority?: string;
+  allowUnencryptedLocalDiscovery?: boolean;
+  timeoutMs?: number;
+  maxResponseBytes?: number;
 }
 
 export interface IHomeAssistantSamsungtvConfig extends ISamsungtvConfig {}
 
-export interface ISamsungtvDeviceInfoResponse {
-  id?: string;
-  device?: ISamsungtvDeviceInfo;
-  [key: string]: unknown;
-}
-
-export interface ISamsungtvDeviceInfo {
-  type?: string;
-  name?: string;
-  modelName?: string;
-  modelNumber?: string;
-  serialNumber?: string;
-  udn?: string;
-  wifiMac?: string;
-  manufacturer?: string;
-  networkType?: string;
-  PowerState?: string;
-  FrameTVSupport?: string;
-  [key: string]: unknown;
-}
-
-export interface ISamsungtvState {
-  power?: TSamsungtvPowerState;
-  playback?: 'playing' | 'paused' | 'idle' | 'off' | 'unknown';
-  volumeLevel?: number;
-  muted?: boolean;
-  source?: string;
-  appId?: string;
-  appName?: string;
-  mediaTitle?: string;
-}
-
-export interface ISamsungtvApp {
-  id: string;
-  name: string;
-  type?: string;
-  appType?: string;
-  version?: string;
+export interface ISamsungtvIntegrationOptions {
+  db: plugins.nosqldb.SmartdataDb;
+  keyProvider: IConfigEncryptionKeyProvider;
 }
 
 export interface ISamsungtvSnapshot {
-  deviceInfo: ISamsungtvDeviceInfoResponse;
-  state?: ISamsungtvState;
-  apps: ISamsungtvApp[];
-  activeApp?: ISamsungtvApp;
-}
-
-export interface ISamsungtvKeyCommand {
-  type: 'key';
-  key: TSamsungtvRemoteKey;
-  action?: TSamsungtvCommandAction;
+  readonly homeId: string;
+  readonly device: plugins.ecobridgeDeviceManager.ISamsungTvDeviceInfo;
+  readonly remoteConnected: boolean;
 }
 
-export interface ISamsungtvLaunchAppCommand {
-  type: 'launch_app';
-  appId: string;
-  appType?: 'DEEP_LINK' | 'NATIVE_LAUNCH' | string;
-  metaTag?: string;
-}
-
-export interface ISamsungtvWebsocketCommand {
-  method: string;
-  params: Record<string, unknown>;
-}
-
-export type TSamsungtvCommand = ISamsungtvKeyCommand | ISamsungtvLaunchAppCommand | ISamsungtvWebsocketCommand;
-
-export interface ISamsungtvEvent {
-  type: 'websocket' | 'state' | 'apps' | 'error';
-  event?: string;
-  data?: unknown;
-  token?: string;
-  timestamp: number;
-}
+export type TSamsungtvRemoteKey = plugins.ecobridgeDeviceManager.TSamsungTvRemoteKey;
 
 export interface ISamsungtvSsdpRecord {
   st?: string;
@@ -133,7 +57,6 @@ export interface ISamsungtvManualEntry {
   model?: string;
   manufacturer?: string;
   macAddress?: string;
-  token?: string;
   metadata?: Record<string, unknown>;
 }