homebridge-smartthings-oauth 1.0.43 → 1.0.44-beta.2

package/CHANGELOG.md

@@ -1,6 +1,29 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [1.0.44] - Samsung Frame TV Local WebSocket Support
+
+### Added
+- **Samsung Frame TV Full Power Off**: Frame TVs now support true power off via a 3.5-second long-press of KEY_POWER sent over local WebSocket. The standard SmartThings `switch.off` command only puts Frame TVs into Art Mode — this bypasses that behavior entirely.
+- **Art Mode Switch**: A separate HomeKit switch to toggle Art Mode on and off for each configured Frame TV. Appears as its own tile in the Home app for easy access and automation.
+- **Local WebSocket Connection Manager** (`src/local/samsungWebSocket.ts`): Handles secure WebSocket connections to Samsung TVs on port 8002 (remote control) and port 8001 (Art Mode channel). Supports lazy connect-on-demand and automatic idle disconnect after 8 seconds.
+- **TV Authorization Token Flow**: First-time connections prompt an "Allow/Deny" popup on the TV. Once accepted, the token is saved automatically and reused for all future connections — no manual pairing code needed.
+- **Frame TV Configuration UI**: New "Samsung Frame TV Settings" section in the Homebridge UI to add/remove Frame TV devices with IP address, full power off toggle, and Art Mode toggle.
+- **Frame TV Auto-Detection**: The plugin automatically detects Frame TVs by checking the `artSupported` field from SmartThings device status. A helpful log message is shown during startup if a Frame TV is found but not yet configured, guiding users to add the TV's local IP address.
+- **`frameTvDevices` config field**: New array in `config.schema.json` for configuring Frame TV devices with `deviceName`, `ip`, `enableFullPowerOff`, `enableArtModeSwitch`, and optional `token` fields.
+- **README section**: Added documentation covering Frame TV auto-detection, configuration options, first-time pairing, troubleshooting, and how to recover from an accidental "Deny" on the TV popup.
+
+### Changed
+- **TelevisionService**: When a Frame TV is configured, power off is intercepted and routed through the local WebSocket instead of the SmartThings API. Power on continues to use the SmartThings API as normal. On WebSocket failure, HomeKit shows "No Response" (no silent fallback to SmartThings).
+- **MultiServiceAccessory**: Detects Frame TV devices by matching the SmartThings device name against `frameTvDevices` config entries (case-insensitive). Creates a shared `SamsungWebSocket` instance used by both the TV service and Art Mode switch.
+- **Platform**: Registers Art Mode accessories as separate platform accessories after device discovery, with UUIDs derived from `deviceId + '-artmode'` to ensure uniqueness.
+
+### Security
+- **Dependency audit**: Fixed all 6 npm audit vulnerabilities (axios, form-data, glob, js-yaml, brace-expansion, diff) — 0 vulnerabilities remaining.
+
+### Dependencies
+- Added `ws` (^8.0.0) and `@types/ws` (^8.0.0) for local WebSocket communication with Samsung TVs.
+
 ## [1.0.43] - Real-Time Subscription Manager UI
 ### Added
 - **Capability Subscription Selector**: New UI card in Homebridge settings to manually choose which capabilities get real-time SmartThings subscriptions (max 20). Available for users with webhooks configured.

package/README.md

@@ -270,6 +270,83 @@ Once webhooks are working, you can control which capabilities get real-time subs
 
 ---
 
+## Samsung Frame TV Support (Optional)
+
+Samsung Frame TVs behave differently from standard TVs: when the SmartThings API sends a power-off command, the TV enters **Art Mode** instead of truly shutting down. This plugin provides optional local WebSocket control to fix this, enabling true power off and an Art Mode toggle switch in HomeKit.
+
+### Auto-Detection
+
+The plugin automatically detects Frame TVs by checking the `artSupported` field reported by SmartThings. If your TV supports Art Mode, you'll see a log message during startup:
+
+> `Frame TV detected: "Living Room TV" reports artSupported=true. To enable full power off and Art Mode control, add this device to the "frameTvDevices" config with its local IP address.`
+
+The local IP address cannot be auto-detected from SmartThings, so you'll need to provide it manually in the configuration.
+
+### What It Does
+
+- **Full Power Off** (optional, enabled by default): Sends a 3.5-second long-press of the power key via local WebSocket, which fully powers down the TV instead of entering Art Mode
+- **Art Mode Switch** (optional, enabled by default): Exposes a separate switch in HomeKit to toggle Art Mode on and off
+- Power **on** continues to work through the SmartThings API as normal
+
+### Configuration Options
+
+You can choose how the plugin handles your Frame TV:
+
+| Setting | Effect |
+|---------|--------|
+| **Full Power Off = ON** (default) | Turning off the TV in HomeKit sends a full power off via local WebSocket. Art Mode switch controls Art Mode separately. |
+| **Full Power Off = OFF** | Turning off the TV in HomeKit uses the standard SmartThings command (which enters Art Mode on Frame TVs). Useful if you prefer the default Samsung behavior. |
+| **Art Mode Switch = ON** (default) | A separate "Art Mode" switch appears in HomeKit for toggling Art Mode on/off. |
+| **Art Mode Switch = OFF** | No Art Mode switch. The TV behaves like a standard TV in HomeKit. |
+
+This means you can mix and match. For example, you could disable Full Power Off but still have the Art Mode switch — giving you the standard Samsung power behavior plus manual Art Mode control.
+
+### Setup
+
+1. Open plugin settings in the Homebridge UI
+2. Scroll down to the **"Samsung Frame TV Settings"** section
+3. Click **"Add Frame TV Device"**
+4. Enter the **device name** (must match exactly how it appears in SmartThings, case-insensitive)
+5. Enter the **TV's local IP address** (assign a static IP on your router for reliability)
+6. Toggle **Full Power Off** and **Art Mode Switch** as desired
+7. Save and restart Homebridge
+
+### First-Time TV Pairing
+
+When Homebridge starts with a Frame TV configured, the plugin will attempt to establish a local WebSocket connection to the TV. On the first connection, the TV needs to authorize the plugin:
+
+1. Make sure the TV is **powered on** before starting Homebridge
+2. After Homebridge starts, a popup will appear on the TV screen asking to allow the connection
+3. Using your TV remote, select **"Allow"** on the popup
+4. The plugin will automatically save an authorization token for future connections — the popup will not appear again
+
+If the pairing fails (e.g., the TV was off or the popup timed out), the plugin will log an error. Simply restart Homebridge with the TV on to retry the pairing process.
+
+### If You Clicked "Deny" by Mistake
+
+If you accidentally denied the connection, the TV remembers this decision and will reject all future connection attempts. To fix this:
+
+1. On your TV, go to **Settings > General > External Device Manager > Device Connection Manager > Device List**
+2. Find the "Homebridge SmartThings" entry and either change its permission to **Allow** or remove the entry entirely
+3. Restart Homebridge to initiate a new pairing
+
+### Troubleshooting Frame TV
+
+**"Connection timeout" errors in the logs**
+- Verify the TV is powered on and connected to the same network as Homebridge
+- Confirm the IP address is correct (check your router's DHCP client list)
+- Make sure no firewall is blocking port 8001 (Art Mode) or port 8002 (remote control)
+
+**"Authorization denied by TV" errors**
+- The saved token may have expired or been invalidated. The plugin will automatically clear the old token. Restart Homebridge with the TV on to get a new authorization popup.
+
+**Art Mode switch not appearing**
+- The Art Mode switch is enabled by default. Check that it hasn't been disabled in the Frame TV device settings.
+- Restart Homebridge after changing the configuration
+- The Art Mode switch appears as a separate tile in HomeKit, not inside the TV accessory
+
+---
+
 ## Troubleshooting
 
 ### Common Issues

package/config.schema.json

@@ -184,6 +184,44 @@
           "type": "string"
         }
       },
+      "frameTvDevices": {
+        "title": "Samsung Frame TV Devices (Local WebSocket Control)",
+        "type": "array",
+        "description": "Configure Samsung Frame TVs for full power off and art mode control via local WebSocket. Only needed for Frame TVs where the SmartThings power-off enters Art Mode instead of truly turning off.",
+        "items": {
+          "type": "object",
+          "properties": {
+            "deviceName": {
+              "title": "Device Name",
+              "type": "string",
+              "description": "Exact SmartThings device name to match (case-insensitive)"
+            },
+            "ip": {
+              "title": "TV IP Address",
+              "type": "string",
+              "description": "Static local IP address of the Samsung Frame TV"
+            },
+            "enableFullPowerOff": {
+              "title": "Enable Full Power Off",
+              "type": "boolean",
+              "default": true,
+              "description": "Use 3.5s long-press KEY_POWER via local WebSocket instead of SmartThings switch.off (which only enters Art Mode on Frame TVs)"
+            },
+            "enableArtModeSwitch": {
+              "title": "Enable Art Mode Switch",
+              "type": "boolean",
+              "default": true,
+              "description": "Expose a separate switch in HomeKit to toggle Art Mode on/off"
+            },
+            "token": {
+              "title": "TV Token (Auto-saved)",
+              "type": "string",
+              "description": "Authorization token from the TV. Usually auto-saved after first connection — leave empty unless troubleshooting."
+            }
+          },
+          "required": ["deviceName", "ip"]
+        }
+      },
       "ShowOnlyDevices": {
         "title": "Show Only Devices (Whitelist)",
         "type": "array",

package/dist/local/samsungWebSocket.d.ts

@@ -0,0 +1,51 @@
+import { Logger } from 'homebridge';
+export declare class SamsungWebSocket {
+    private readonly ip;
+    private readonly log;
+    private readonly appName;
+    private readonly storagePath;
+    private token;
+    private remoteWs;
+    private artWs;
+    private idleTimer;
+    private readonly idleTimeoutMs;
+    private connecting;
+    private artConnecting;
+    constructor(ip: string, log: Logger, storagePath: string, token?: string, appName?: string);
+    private get encodedAppName();
+    private get remoteUrl();
+    private get artModeUrl();
+    private get tokenFilePath();
+    private loadToken;
+    private saveToken;
+    private handleConnectMessage;
+    private connectRemote;
+    private connectArtMode;
+    private resetIdleTimer;
+    private disconnectRemote;
+    private disconnectArt;
+    private sendKey;
+    /**
+     * Send a click (short press) of a key
+     */
+    clickKey(key: string): Promise<void>;
+    /**
+     * Hold a key for the specified duration (press, wait, release)
+     * Used for Frame TV full power off (3.5s hold of KEY_POWER)
+     */
+    holdKey(key: string, durationMs: number): Promise<void>;
+    /**
+     * Get current art mode status
+     * Returns 'on' or 'off'
+     */
+    getArtModeStatus(): Promise<string>;
+    /**
+     * Set art mode status ('on' or 'off')
+     */
+    setArtModeStatus(status: 'on' | 'off'): Promise<void>;
+    /**
+     * Clean up all connections
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=samsungWebSocket.d.ts.map

package/dist/local/samsungWebSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"samsungWebSocket.d.ts","sourceRoot":"","sources":["../../src/local/samsungWebSocket.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAIpC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;gBAElB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,SAA2B;IAa5G,OAAO,KAAK,cAAc,GAEzB;IAED,OAAO,KAAK,SAAS,GAMpB;IAED,OAAO,KAAK,UAAU,GAGrB;IAED,OAAO,KAAK,aAAa,GAIxB;IAED,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,aAAa;IAiGrB,OAAO,CAAC,cAAc;IA6FtB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,OAAO;IAcf;;OAEG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1C;;;OAGG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7D;;;OAGG;IACG,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAmDzC;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,IAAI,GAAG,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB3D;;OAEG;IACH,OAAO,IAAI,IAAI;CAShB"}

package/dist/local/samsungWebSocket.js

@@ -0,0 +1,433 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SamsungWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class SamsungWebSocket {
+    constructor(ip, log, storagePath, token, appName = 'Homebridge SmartThings') {
+        this.remoteWs = null;
+        this.artWs = null;
+        this.idleTimer = null;
+        this.idleTimeoutMs = 8000;
+        this.connecting = false;
+        this.artConnecting = false;
+        this.ip = ip;
+        this.log = log;
+        this.appName = appName;
+        this.storagePath = storagePath;
+        this.token = token || null;
+        // Try to load a previously saved token if none was provided
+        if (!this.token) {
+            this.token = this.loadToken();
+        }
+    }
+    get encodedAppName() {
+        return Buffer.from(this.appName).toString('base64');
+    }
+    get remoteUrl() {
+        let url = `wss://${this.ip}:8002/api/v2/channels/samsung.remote.control?name=${this.encodedAppName}`;
+        if (this.token) {
+            url += `&token=${this.token}`;
+        }
+        return url;
+    }
+    get artModeUrl() {
+        // Art mode channel uses unencrypted WS on port 8001 (no token needed)
+        return `ws://${this.ip}:8001/api/v2/channels/com.samsung.art-app?name=${this.encodedAppName}`;
+    }
+    get tokenFilePath() {
+        // Sanitize IP for filename
+        const safeIp = this.ip.replace(/[^a-zA-Z0-9.-]/g, '_');
+        return path.join(this.storagePath, `samsung_tv_token_${safeIp}.json`);
+    }
+    loadToken() {
+        try {
+            if (fs.existsSync(this.tokenFilePath)) {
+                const data = JSON.parse(fs.readFileSync(this.tokenFilePath, 'utf-8'));
+                if (data.token) {
+                    this.log.debug(`Samsung WebSocket: Loaded saved token for ${this.ip}`);
+                    return data.token;
+                }
+            }
+        }
+        catch (err) {
+            this.log.debug(`Samsung WebSocket: Could not load saved token for ${this.ip}: ${err}`);
+        }
+        return null;
+    }
+    saveToken(token) {
+        try {
+            fs.writeFileSync(this.tokenFilePath, JSON.stringify({ token, ip: this.ip, savedAt: new Date().toISOString() }));
+            this.log.info(`Samsung WebSocket: Token saved for ${this.ip} — future connections will skip TV authorization popup`);
+        }
+        catch (err) {
+            this.log.warn(`Samsung WebSocket: Could not save token for ${this.ip}: ${err}`);
+        }
+    }
+    handleConnectMessage(msg) {
+        var _a;
+        // Samsung TVs return a token in the ms.channel.connect event data
+        // This token must be saved and used for future connections to skip the Allow/Deny popup
+        const tokenFromTv = (_a = msg.data) === null || _a === void 0 ? void 0 : _a.token;
+        if (tokenFromTv && tokenFromTv !== this.token) {
+            this.log.info(`Samsung WebSocket: Received authorization token from TV at ${this.ip}`);
+            this.token = tokenFromTv;
+            this.saveToken(tokenFromTv);
+        }
+    }
+    connectRemote() {
+        return new Promise((resolve, reject) => {
+            if (this.remoteWs && this.remoteWs.readyState === ws_1.default.OPEN) {
+                this.resetIdleTimer();
+                resolve(this.remoteWs);
+                return;
+            }
+            if (this.connecting) {
+                const waitInterval = setInterval(() => {
+                    if (!this.connecting) {
+                        clearInterval(waitInterval);
+                        if (this.remoteWs && this.remoteWs.readyState === ws_1.default.OPEN) {
+                            resolve(this.remoteWs);
+                        }
+                        else {
+                            reject(new Error('Remote WebSocket connection failed while waiting'));
+                        }
+                    }
+                }, 100);
+                return;
+            }
+            this.connecting = true;
+            const hasToken = !!this.token;
+            this.log.debug(`Samsung WebSocket: Connecting to remote control at ${this.ip}:8002 (token=${hasToken ? 'yes' : 'NO — TV will show Allow/Deny popup'})`);
+            if (!hasToken) {
+                this.log.warn(`Samsung WebSocket: No saved token for ${this.ip}. ` +
+                    'The TV will display an "Allow" popup. Please accept it on the TV screen. ' +
+                    'The token will be saved automatically for future connections.');
+            }
+            const ws = new ws_1.default(this.remoteUrl, { rejectUnauthorized: false });
+            // Give extra time for first-time authorization (user needs to press Allow on TV)
+            const timeoutMs = hasToken ? 5000 : 30000;
+            const connectTimeout = setTimeout(() => {
+                this.connecting = false;
+                ws.terminate();
+                const msg = hasToken
+                    ? `Samsung WebSocket: Connection timeout to ${this.ip} (TV may be off)`
+                    : `Samsung WebSocket: Connection timeout to ${this.ip} — did you accept the "Allow" popup on the TV?`;
+                reject(new Error(msg));
+            }, timeoutMs);
+            ws.on('open', () => {
+                this.log.debug(`Samsung WebSocket: TCP connected to ${this.ip}:8002, waiting for channel connect...`);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.event === 'ms.channel.connect') {
+                        clearTimeout(connectTimeout);
+                        this.handleConnectMessage(msg);
+                        this.log.debug('Samsung WebSocket: Remote control channel connected');
+                        this.remoteWs = ws;
+                        this.connecting = false;
+                        this.resetIdleTimer();
+                        resolve(ws);
+                    }
+                    else if (msg.event === 'ms.channel.unauthorized') {
+                        clearTimeout(connectTimeout);
+                        this.connecting = false;
+                        ws.terminate();
+                        // Token is invalid/expired — clear it so next attempt shows popup
+                        this.token = null;
+                        try {
+                            fs.unlinkSync(this.tokenFilePath);
+                        }
+                        catch ( /* ignore */_a) { /* ignore */ }
+                        reject(new Error(`Samsung WebSocket: Authorization denied by TV at ${this.ip}. ` +
+                            'Saved token was invalid. Restart Homebridge to retry — the TV will show a new Allow/Deny popup.'));
+                    }
+                }
+                catch (_b) {
+                    // Ignore non-JSON messages
+                }
+            });
+            ws.on('error', (err) => {
+                clearTimeout(connectTimeout);
+                this.connecting = false;
+                this.log.error(`Samsung WebSocket: Remote connection error: ${err.message}`);
+                reject(err);
+            });
+            ws.on('close', () => {
+                clearTimeout(connectTimeout);
+                this.connecting = false;
+                if (this.remoteWs === ws) {
+                    this.remoteWs = null;
+                }
+                this.log.debug('Samsung WebSocket: Remote control connection closed');
+            });
+        });
+    }
+    connectArtMode() {
+        return new Promise((resolve, reject) => {
+            if (this.artWs && this.artWs.readyState === ws_1.default.OPEN) {
+                resolve(this.artWs);
+                return;
+            }
+            if (this.artConnecting) {
+                const waitInterval = setInterval(() => {
+                    if (!this.artConnecting) {
+                        clearInterval(waitInterval);
+                        if (this.artWs && this.artWs.readyState === ws_1.default.OPEN) {
+                            resolve(this.artWs);
+                        }
+                        else {
+                            reject(new Error('Art mode WebSocket connection failed while waiting'));
+                        }
+                    }
+                }, 100);
+                return;
+            }
+            this.artConnecting = true;
+            this.log.debug(`Samsung WebSocket: Connecting to art mode channel at ${this.ip}:8001`);
+            const ws = new ws_1.default(this.artModeUrl);
+            const connectTimeout = setTimeout(() => {
+                this.artConnecting = false;
+                ws.terminate();
+                reject(new Error(`Samsung WebSocket: Art mode connection timeout to ${this.ip}`));
+            }, 5000);
+            ws.on('open', () => {
+                this.log.debug(`Samsung WebSocket: TCP connected to art mode channel at ${this.ip}:8001`);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.event === 'ms.channel.connect') {
+                        // Art channel on port 8001 may also return a token
+                        this.handleConnectMessage(msg);
+                        this.log.debug('Samsung WebSocket: Art mode channel connected');
+                    }
+                    else if (msg.event === 'ms.channel.ready') {
+                        // Reference: samsung-tizen plugin resolves on ms.channel.ready
+                        clearTimeout(connectTimeout);
+                        if (!this.artWs) {
+                            this.artWs = ws;
+                            this.artConnecting = false;
+                            resolve(ws);
+                        }
+                    }
+                    else if (msg.event === 'd2d_service_message') {
+                        clearTimeout(connectTimeout);
+                        if (!this.artWs) {
+                            this.artWs = ws;
+                            this.artConnecting = false;
+                            resolve(ws);
+                        }
+                    }
+                }
+                catch (_a) {
+                    // Ignore non-JSON messages
+                }
+            });
+            // Fallback: some TVs don't send a connect message on the art channel
+            const fallbackTimeout = setTimeout(() => {
+                if (!this.artWs && ws.readyState === ws_1.default.OPEN) {
+                    this.artWs = ws;
+                    this.artConnecting = false;
+                    resolve(ws);
+                }
+            }, 2000);
+            ws.on('error', (err) => {
+                clearTimeout(connectTimeout);
+                clearTimeout(fallbackTimeout);
+                this.artConnecting = false;
+                this.log.error(`Samsung WebSocket: Art mode connection error: ${err.message}`);
+                reject(err);
+            });
+            ws.on('close', () => {
+                clearTimeout(connectTimeout);
+                clearTimeout(fallbackTimeout);
+                this.artConnecting = false;
+                if (this.artWs === ws) {
+                    this.artWs = null;
+                }
+                this.log.debug('Samsung WebSocket: Art mode connection closed');
+            });
+        });
+    }
+    resetIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+        }
+        this.idleTimer = setTimeout(() => {
+            this.disconnectRemote();
+        }, this.idleTimeoutMs);
+    }
+    disconnectRemote() {
+        if (this.remoteWs) {
+            this.log.debug('Samsung WebSocket: Disconnecting remote (idle timeout)');
+            this.remoteWs.close();
+            this.remoteWs = null;
+        }
+    }
+    disconnectArt() {
+        if (this.artWs) {
+            this.log.debug('Samsung WebSocket: Disconnecting art mode');
+            this.artWs.close();
+            this.artWs = null;
+        }
+    }
+    sendKey(ws, cmd, key) {
+        const payload = JSON.stringify({
+            method: 'ms.remote.control',
+            params: {
+                Cmd: cmd,
+                DataOfCmd: key,
+                Option: false,
+                TypeOfRemote: 'SendRemoteKey',
+            },
+        });
+        this.log.debug(`Samsung WebSocket: Sending key ${cmd} ${key}`);
+        ws.send(payload);
+    }
+    /**
+     * Send a click (short press) of a key
+     */
+    async clickKey(key) {
+        const ws = await this.connectRemote();
+        this.sendKey(ws, 'Click', key);
+    }
+    /**
+     * Hold a key for the specified duration (press, wait, release)
+     * Used for Frame TV full power off (3.5s hold of KEY_POWER)
+     */
+    async holdKey(key, durationMs) {
+        const ws = await this.connectRemote();
+        this.sendKey(ws, 'Press', key);
+        await new Promise(resolve => setTimeout(resolve, durationMs));
+        this.sendKey(ws, 'Release', key);
+        this.log.debug(`Samsung WebSocket: Held ${key} for ${durationMs}ms`);
+    }
+    /**
+     * Get current art mode status
+     * Returns 'on' or 'off'
+     */
+    async getArtModeStatus() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const ws = await this.connectArtMode();
+                const timeout = setTimeout(() => {
+                    this.disconnectArt();
+                    // Default to 'off' if we can't determine status
+                    resolve('off');
+                }, 3000);
+                const messageHandler = (data) => {
+                    try {
+                        const msg = JSON.parse(data.toString());
+                        if (msg.event === 'd2d_service_message' && msg.data) {
+                            const eventData = typeof msg.data === 'string' ? JSON.parse(msg.data) : msg.data;
+                            if (eventData.event === 'art_mode_changed' || eventData.event === 'artmode_status') {
+                                clearTimeout(timeout);
+                                ws.removeListener('message', messageHandler);
+                                const status = eventData.value === 'on' || eventData.status === 'on' ? 'on' : 'off';
+                                this.log.debug(`Samsung WebSocket: Art mode status: ${status}`);
+                                this.disconnectArt();
+                                resolve(status);
+                            }
+                        }
+                    }
+                    catch (_a) {
+                        // Ignore parse errors
+                    }
+                };
+                ws.on('message', messageHandler);
+                // Request art mode status
+                const request = JSON.stringify({
+                    method: 'ms.channel.emit',
+                    params: {
+                        event: 'art_app_request',
+                        to: 'host',
+                        data: JSON.stringify({
+                            request: 'get_artmode_status',
+                            id: String(Date.now()),
+                        }),
+                    },
+                });
+                ws.send(request);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    /**
+     * Set art mode status ('on' or 'off')
+     */
+    async setArtModeStatus(status) {
+        const ws = await this.connectArtMode();
+        const request = JSON.stringify({
+            method: 'ms.channel.emit',
+            params: {
+                event: 'art_app_request',
+                to: 'host',
+                data: JSON.stringify({
+                    request: 'set_artmode_status',
+                    value: status,
+                    id: String(Date.now()),
+                }),
+            },
+        });
+        this.log.debug(`Samsung WebSocket: Setting art mode to ${status}`);
+        ws.send(request);
+        // Give the TV a moment to process, then disconnect
+        await new Promise(resolve => setTimeout(resolve, 500));
+        this.disconnectArt();
+    }
+    /**
+     * Clean up all connections
+     */
+    destroy() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        this.disconnectRemote();
+        this.disconnectArt();
+        this.log.debug('Samsung WebSocket: All connections closed');
+    }
+}
+exports.SamsungWebSocket = SamsungWebSocket;
+//# sourceMappingURL=samsungWebSocket.js.map