amaran-light-cli 1.5.0 → 1.7.0

package/dist/deviceControl/lightControl.js

@@ -26,15 +26,135 @@ Downloaded from: https://gist.github.com/zsprackett/29334b9be1e2bd90c1737bd0ba0e
 import chalk from 'chalk';
 import WebSocket from 'ws';
 import { DEVICE_DEFAULTS } from './constants.js';
+/**
+ * Control Aputure Amaran Lights via websocket to the amaran Desktop application.
+ *
+ * @class LightController
+ */
 class LightController {
+    ws;
+    clientId = 'unknown_client';
+    deviceList = [];
+    sceneList = [];
+    nodeConfigs = new Map();
+    commandCallbacks = new Map();
+    pendingQueue = [];
+    onInitializedCallback;
+    debug = false;
+    constructor(wsUrl, clientId, onInitialized, debug = false) {
+        this.ws = new WebSocket(wsUrl);
+        if (clientId) {
+            this.clientId = clientId;
+        }
+        this.debug = debug;
+        if (onInitialized) {
+            this.onInitializedCallback = onInitialized;
+        }
+        this.ws.on('open', () => {
+            this.log('Connected to WebSocket server');
+            this.flushPending();
+            this.onConnectionOpen();
+        });
+        this.ws.on('message', (data) => this.handleMessage(data));
+        this.ws.on('error', (error) => {
+            if (this.debug) {
+                console.error('WebSocket error:', error);
+            }
+            else {
+                const addressMatch = error.message.match(/(\S+:\d+)/);
+                const addressPort = addressMatch ? addressMatch[1] : this.ws.url;
+                console.error(chalk.red(`WebSocket connection failed to ${addressPort}`));
+            }
+        });
+        this.ws.on('close', () => {
+            this.log('Disconnected from WebSocket server');
+        });
+    }
+    // --- Initialization & Message Handling ---
+    onConnectionOpen() {
+        this.getDeviceList();
+    }
+    handleMessage(data) {
+        try {
+            const parsedData = JSON.parse(data.toString());
+            this.log('Received message from server:', parsedData);
+            const action = parsedData.action || parsedData.request?.type;
+            if (parsedData.code !== 0) {
+                console.error('Error from server:', parsedData.message);
+                if (action && this.commandCallbacks.has(action)) {
+                    this.commandCallbacks.get(action)?.(false, parsedData.message);
+                    this.commandCallbacks.delete(action);
+                }
+                return;
+            }
+            if (action && this.commandCallbacks.has(action)) {
+                this.commandCallbacks.get(action)?.(true, parsedData.message, parsedData.data);
+                this.commandCallbacks.delete(action);
+            }
+            if (action) {
+                this.processResponseType(action, parsedData.data, parsedData.node_id);
+            }
+        }
+        catch (error) {
+            console.error('Error parsing message:', error);
+        }
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic data from server needs flexible typing before validation
+    processResponseType(type, data, nodeId) {
+        switch (type) {
+            case 'get_device_list':
+            case 'get_fixture_list':
+                this.handleDeviceList(data);
+                break;
+            case 'get_scene_list':
+                this.handleSceneList(data);
+                break;
+            case 'get_node_config':
+                this.handleNodeConfig({ node_id: nodeId, data });
+                break;
+            default:
+                this.log('Response type processed:', type);
+        }
+    }
+    handleDeviceList(data) {
+        this.deviceList = data.data;
+        this.log('Device List:', JSON.stringify(this.deviceList, null, 2));
+        this.getSceneList();
+    }
+    handleSceneList(data) {
+        this.sceneList = data.data;
+        this.log('Scene List:', JSON.stringify(this.sceneList, null, 2));
+        this.getNodeConfigs();
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Payload can be flat or nested from different server versions
+    handleNodeConfig(payload) {
+        const nodeId = payload.node_id || payload.data?.node_id;
+        if (nodeId) {
+            let config = payload.data;
+            // If server returned nested data: { node_id, data: { ...config } }
+            if (config && typeof config === 'object' && 'data' in config && ('node_id' in config || 'id' in config)) {
+                config = config.data;
+            }
+            this.nodeConfigs.set(nodeId, config);
+            this.log('Node Config:', JSON.stringify(config, null, 2));
+            if (this.nodeConfigs.size === this.deviceList.length) {
+                this.log('All node configurations have been gathered');
+                if (this.onInitializedCallback) {
+                    this.onInitializedCallback();
+                }
+            }
+        }
+    }
+    getNodeConfigs() {
+        this.deviceList.forEach((device) => {
+            if (device.node_id) {
+                this.getNodeConfig(device.node_id);
+            }
+        });
+    }
+    // --- Convenience Methods (Applied to All Lights) ---
     /**
      * Apply a command to all light devices with throttling.
-     * Only targets devices with node_ids matching the light pattern (e.g., '400J5-F2C008').
-     * Throttles commands with ${DEVICE_DEFAULTS.commandThrottleDelay}ms delay between each to avoid overwhelming the server.
-     *
-     * @param commandFn - Function that takes (nodeId, callback) and executes the command
-     * @param commandName - Display name for the command (for logging)
-     * @param getDisplayArgs - Optional function to get display arguments for logging
      */
     async applyToAllLights(commandFn, commandName, getDisplayArgs) {
         try {
@@ -42,7 +162,6 @@ class LightController {
                 this.log('No devices found');
                 return;
             }
-            // Filter for light devices (node_ids that look like light IDs)
             const lightDevices = this.deviceList.filter((device) => device.node_id ? this.isLightNodeId(device.node_id) : false);
             if (lightDevices.length === 0) {
                 this.log('No light devices found');
@@ -50,19 +169,16 @@ class LightController {
             }
             this.log(`${commandName} for ${lightDevices.length} light(s)`);
             const waitTimeMs = DEVICE_DEFAULTS.commandThrottleDelay;
-            // Send commands with waitTimeMs throttling between each
             for (let i = 0; i < lightDevices.length; i++) {
                 const device = lightDevices[i];
                 const displayName = device.device_name || device.name || device.node_id || 'Unknown';
                 const displayArgs = getDisplayArgs ? getDisplayArgs(device) : '';
-                // Only log if we're not in test environment
                 if (process.env.NODE_ENV !== 'test') {
                     console.log(`  ${commandName} ${displayName} (${device.node_id})${displayArgs}`);
                 }
                 if (device.node_id) {
                     commandFn(device.node_id);
                 }
-                // Wait waitTimeMs before sending next command (skip delay after last one)
                 if (i < lightDevices.length - 1) {
                     await this.sleep(waitTimeMs);
                 }
@@ -73,226 +189,105 @@ class LightController {
             throw error;
         }
     }
-    /**
-     * Set CCT & Intensity for all lights in deviceList.
-     * Only targets devices with node_ids matching the light pattern (e.g., '400J5-F2C008').
-     * Throttles commands with ${DEVICE_DEFAULTS.commandThrottleDelay}ms delay between each to avoid overwhelming the server.
-     */
     async setCCTAndIntensityForAllLights(cct, intensity, callback) {
         await this.applyToAllLights((nodeId) => this.setCCT(nodeId, cct, intensity, callback), 'Setting CCT', () => ` to ${cct}K${intensity !== undefined ? ` at ${intensity / 10}%` : ''}`);
     }
-    /**
-     * Turn on all lights.
-     */
     async turnOnAllLights(callback) {
         await this.applyToAllLights((nodeId) => this.turnLightOn(nodeId, callback), 'Turning on');
     }
-    /**
-     * Turn off all lights.
-     */
     async turnOffAllLights(callback) {
         await this.applyToAllLights((nodeId) => this.turnLightOff(nodeId, callback), 'Turning off');
     }
-    /**
-     * Toggle all lights.
-     */
     async toggleAllLights(callback) {
         await this.applyToAllLights((nodeId) => this.toggleLight(nodeId, callback), 'Toggling');
     }
-    /**
-     * Set intensity for all lights.
-     */
     async setIntensityForAllLights(intensity, callback) {
         await this.applyToAllLights((nodeId) => this.setIntensity(nodeId, intensity, callback), 'Setting intensity', () => ` to ${intensity / 10}%`);
     }
-    /**
-     * Increment intensity for all lights.
-     */
     async incrementIntensityForAllLights(delta, callback) {
         await this.applyToAllLights((nodeId) => this.incrementIntensity(nodeId, delta, callback), 'Incrementing intensity', () => ` by ${delta > 0 ? '+' : ''}${delta / 10}%`);
     }
-    /**
-     * Increment CCT for all lights.
-     */
     async incrementCCTForAllLights(delta, intensity, callback) {
         await this.applyToAllLights((nodeId) => this.incrementCCT(nodeId, delta, intensity, callback), 'Incrementing CCT', () => ` by ${delta > 0 ? '+' : ''}${delta}K${intensity !== undefined ? ` at ${intensity / 10}%` : ''}`);
     }
-    /**
-     * Set HSI color for all lights.
-     */
     async setHSIForAllLights(hue, sat, intensity, cct, gm, callback) {
         await this.applyToAllLights((nodeId) => this.setHSI(nodeId, hue, sat, intensity, cct, gm, callback), 'Setting HSI', () => ` to H:${hue} S:${sat} I:${intensity / 10}%`);
     }
-    /**
-     * Set color for all lights.
-     */
     async setColorForAllLights(color, intensity, callback) {
         await this.applyToAllLights((nodeId) => this.setColor(nodeId, color, intensity, callback), 'Setting color', () => ` to ${color}${intensity !== undefined ? ` at ${intensity / 10}%` : ''}`);
     }
-    /**
-     * Set system effect for all lights.
-     */
     async setSystemEffectForAllLights(effectType, intensity, callback) {
         await this.applyToAllLights((nodeId) => this.setSystemEffect(nodeId, effectType, intensity, callback), 'Setting effect', () => ` to ${effectType}${intensity !== undefined ? ` at ${intensity / 10}%` : ''}`);
     }
-    /**
-     * Check if a node_id looks like a light device (not a group or other entity).
-     * Light node_ids typically follow pattern like '400J5-F2C008' (alphanumeric with dash).
-     */
-    isLightNodeId(nodeId) {
-        // Pattern: contains at least one dash and alphanumeric characters
-        // Excludes things like 'all', 'group1', etc.
-        const lightPattern = /^[A-Z0-9]+-[A-Z0-9]+$/i;
-        return lightPattern.test(nodeId);
+    // --- Individual Light Control Methods ---
+    getProtocolVersions(callback) {
+        this.sendCommand(undefined, 'get_protocol_versions', {}, callback);
     }
-    /**
-     * Sleep utility for throttling commands
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    getFixtureList(callback) {
+        this.sendCommand(undefined, 'get_fixture_list', {}, callback);
     }
-    ws;
-    clientId = 'unknown_client';
-    deviceList = [];
-    sceneList = [];
-    nodeConfigs = new Map();
-    debug;
-    onInitializedCallback;
-    commandCallbacks = new Map();
-    pendingQueue = [];
-    constructor(wsUrl, clientId, onInitialized, debug = false) {
-        this.ws = new WebSocket(wsUrl);
-        if (clientId) {
-            this.clientId = clientId;
-        }
-        this.debug = debug;
-        if (onInitialized) {
-            this.onInitializedCallback = onInitialized;
-        }
-        this.ws.on('open', () => {
-            this.log('Connected to WebSocket server');
-            // Flush any queued commands that were issued before the socket was open
-            this.flushPending();
-            this.onConnectionOpen();
-        });
-        this.ws.on('message', (data) => {
-            try {
-                const parsedData = JSON.parse(data.toString());
-                this.log('Received message from server:', parsedData);
-                const requestId = parsedData.request?.type;
-                if (parsedData.code !== 0) {
-                    console.error('Error from server:', parsedData.message);
-                    if (requestId && this.commandCallbacks.has(requestId)) {
-                        this.commandCallbacks.get(requestId)?.(false, parsedData.message);
-                        this.commandCallbacks.delete(requestId);
-                    }
-                    return;
-                }
-                if (requestId && this.commandCallbacks.has(requestId)) {
-                    this.commandCallbacks.get(requestId)?.(true, parsedData.message, parsedData.data);
-                    this.commandCallbacks.delete(requestId);
-                }
-                if (parsedData.request?.type) {
-                    switch (parsedData.request.type) {
-                        case 'get_device_list':
-                            this.handleDeviceList(parsedData.data);
-                            break;
-                        case 'get_scene_list':
-                            this.handleSceneList(parsedData.data);
-                            break;
-                        case 'get_node_config':
-                            this.handleNodeConfig(parsedData.data);
-                            break;
-                        default:
-                            this.log('Unknown response type');
-                    }
-                }
-            }
-            catch (error) {
-                console.error('Error parsing message:', error);
-            }
-        });
-        this.ws.on('error', (error) => {
-            if (this.debug) {
-                console.error('WebSocket error:', error);
-            }
-            else {
-                // Extract address and port from the error message for cleaner output
-                const addressMatch = error.message.match(/(\S+:\d+)/);
-                const addressPort = addressMatch ? addressMatch[1] : this.ws.url;
-                console.error(chalk.red(`WebSocket connection failed to ${addressPort}`));
-            }
-        });
-        this.ws.on('close', () => {
-            this.log('Disconnected from WebSocket server');
-        });
+    getDeviceList(callback) {
+        this.sendCommand(undefined, 'get_device_list', {}, callback);
     }
-    // Public getter for WebSocket to allow external error handling
-    getWebSocket() {
-        return this.ws;
+    getDeviceInfo(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_device_info', {}, callback);
     }
-    setClientId(clientId) {
-        this.clientId = clientId;
+    getFirmwareVersion(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_firmware_version', {}, callback);
     }
-    onConnectionOpen() {
-        this.getDeviceList();
+    checkForUpdates(nodeId, callback) {
+        this.sendCommand(nodeId, 'check_for_updates', {}, callback);
     }
-    sendCommand(nodeId, type, args, callback) {
-        if (this.ws.readyState === WebSocket.OPEN) {
-            const command = {
-                version: 1,
-                client_id: this.clientId,
-                type,
-                node_id: nodeId,
-                args,
-            };
-            if (callback) {
-                this.commandCallbacks.set(type, callback);
-            }
-            this.ws.send(JSON.stringify(command));
-            this.log(`Sent command: ${type}`);
-        }
-        else {
-            // Queue the command to be sent when the socket opens
-            this.pendingQueue.push({ nodeId, type, args, callback });
-            this.log(`Queued command (socket not open yet): ${type}`);
-        }
+    updateFirmware(nodeId, callback) {
+        this.sendCommand(nodeId, 'update_firmware', {}, callback);
     }
-    handleDeviceList(data) {
-        this.deviceList = data.data;
-        this.log('Device List:', JSON.stringify(this.deviceList, null, 2));
-        this.getSceneList();
+    getSceneList(callback) {
+        this.sendCommand(undefined, 'get_scene_list', {}, callback);
     }
-    handleSceneList(data) {
-        this.sceneList = data.data;
-        this.log('Scene List:', JSON.stringify(this.sceneList, null, 2));
-        this.getNodeConfigs();
+    saveScene(name, callback) {
+        this.sendCommand(undefined, 'save_scene', { name }, callback);
     }
-    handleNodeConfig(data) {
-        const nodeId = data.node_id;
-        if (nodeId) {
-            this.nodeConfigs.set(nodeId, data.data);
-            this.log('Node Config:', JSON.stringify(data.data, null, 2));
-            if (this.nodeConfigs.size === this.deviceList.length) {
-                this.log('All node configurations have been gathered');
-                if (this.onInitializedCallback) {
-                    this.onInitializedCallback();
-                }
-            }
-        }
+    deleteScene(sceneId, callback) {
+        this.sendCommand(undefined, 'delete_scene', { id: sceneId }, callback);
     }
-    getNodeConfigs() {
-        this.deviceList.forEach((device) => {
-            if (device.node_id) {
-                this.getNodeConfig(device.node_id);
-            }
-        });
+    recallScene(sceneId, callback) {
+        this.sendCommand(undefined, 'recall_scene', { id: sceneId }, callback);
     }
-    getDeviceList(callback) {
-        this.sendCommand(undefined, 'get_device_list', {}, callback);
+    updateScene(sceneId, name, callback) {
+        this.sendCommand(undefined, 'update_scene', { id: sceneId, name }, callback);
     }
-    getSceneList(callback) {
-        this.sendCommand(undefined, 'get_scene_list', {}, callback);
+    getPresetList(callback) {
+        this.sendCommand(undefined, 'get_preset_list', {}, callback);
+    }
+    recallPreset(nodeId, presetId, callback) {
+        this.sendCommand(nodeId, 'recall_preset', { id: presetId }, callback);
+    }
+    setPreset(nodeId, presetId, callback) {
+        this.sendCommand(nodeId, 'set_preset', { preset_id: presetId }, callback);
+    }
+    getSystemEffectList(callback) {
+        this.sendCommand(undefined, 'get_system_effect_list', {}, callback);
+    }
+    getQuickshotList(callback) {
+        this.sendCommand(undefined, 'get_quickshot_list', {}, callback);
+    }
+    setQuickshot(quickshotId, callback) {
+        this.sendCommand(undefined, 'set_quickshot', { quickshot_id: quickshotId }, callback);
+    }
+    getGroupList(callback) {
+        this.sendCommand(undefined, 'get_group_list', {}, callback);
+    }
+    createGroup(name, callback) {
+        this.sendCommand(undefined, 'create_group', { name }, callback);
+    }
+    deleteGroup(groupId, callback) {
+        this.sendCommand(undefined, 'delete_group', { id: groupId }, callback);
+    }
+    addToGroup(groupId, nodeId, callback) {
+        this.sendCommand(undefined, 'add_to_group', { group_id: groupId, node_id: nodeId }, callback);
+    }
+    removeFromGroup(groupId, nodeId, callback) {
+        this.sendCommand(undefined, 'remove_from_group', { group_id: groupId, node_id: nodeId }, callback);
     }
     getNodeConfig(nodeId, callback) {
         this.sendCommand(nodeId, 'get_node_config', {}, callback);
@@ -309,11 +304,17 @@ class LightController {
     toggleLight(nodeId, callback) {
         this.sendCommand(nodeId, 'toggle_sleep', undefined, callback);
     }
+    getIntensity(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_intensity', {}, callback);
+    }
     setIntensity(nodeId, intensity, callback) {
         this.sendCommand(nodeId, 'set_intensity', { intensity }, callback);
     }
     incrementIntensity(nodeId, delta, callback) {
-        this.sendCommand(nodeId, 'increment_intensity', { delta }, callback);
+        this.sendCommand(nodeId, 'increase_intensity', { delta }, callback);
+    }
+    getCCT(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_cct', {}, callback);
     }
     setCCT(nodeId, cct, intensity, callback) {
         const args = { cct };
@@ -327,7 +328,10 @@ class LightController {
         if (intensity !== undefined) {
             args.intensity = intensity;
         }
-        this.sendCommand(nodeId, 'increment_cct', args, callback);
+        this.sendCommand(nodeId, 'increase_cct', args, callback);
+    }
+    getHSI(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_hsi', {}, callback);
     }
     setHSI(nodeId, hue, sat, intensity, cct, gm, callback) {
         const args = { hue, sat, intensity };
@@ -339,6 +343,26 @@ class LightController {
         }
         this.sendCommand(nodeId, 'set_hsi', args, callback);
     }
+    getRGB(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_rgb', {}, callback);
+    }
+    setRGB(nodeId, r, g, b, intensity, callback) {
+        const args = { r, g, b };
+        if (intensity !== undefined) {
+            args.intensity = intensity;
+        }
+        this.sendCommand(nodeId, 'set_rgb', args, callback);
+    }
+    getXY(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_xy', {}, callback);
+    }
+    setXY(nodeId, x, y, intensity, callback) {
+        const args = { x, y };
+        if (intensity !== undefined) {
+            args.intensity = intensity;
+        }
+        this.sendCommand(nodeId, 'set_xy', args, callback);
+    }
     setColor(nodeId, color, intensity, callback) {
         const args = { color };
         if (intensity !== undefined) {
@@ -346,6 +370,9 @@ class LightController {
         }
         this.sendCommand(nodeId, 'set_color', args, callback);
     }
+    getSystemEffect(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_system_effect', {}, callback);
+    }
     setSystemEffect(nodeId, effectType, intensity, callback) {
         const args = { effect_type: effectType };
         if (intensity !== undefined) {
@@ -353,6 +380,32 @@ class LightController {
         }
         this.sendCommand(nodeId, 'set_system_effect', args, callback);
     }
+    getEffect(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_effect', {}, callback);
+    }
+    setEffect(nodeId, effectName, args, callback) {
+        const combinedArgs = { name: effectName, ...args };
+        this.sendCommand(nodeId, 'set_effect', combinedArgs, callback);
+    }
+    getFanMode(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_fan_mode', {}, callback);
+    }
+    setFanMode(nodeId, mode, callback) {
+        this.sendCommand(nodeId, 'set_fan_mode', { mode }, callback);
+    }
+    getFanSpeed(nodeId, callback) {
+        this.sendCommand(nodeId, 'get_fan_speed', {}, callback);
+    }
+    setFanSpeed(nodeId, speed, callback) {
+        this.sendCommand(nodeId, 'set_fan_speed', { speed }, callback);
+    }
+    setEffectSpeed(nodeId, speed, callback) {
+        this.sendCommand(nodeId, 'set_effect_speed', { speed }, callback);
+    }
+    setEffectIntensity(nodeId, intensity, callback) {
+        this.sendCommand(nodeId, 'set_effect_intensity', { intensity }, callback);
+    }
+    // --- Utility & Infrastructure ---
     async disconnect() {
         if (this.ws.readyState === WebSocket.OPEN) {
             await this.waitForPendingCommands(5000);
@@ -377,19 +430,27 @@ class LightController {
             checkPendingCommands();
         });
     }
-    // Getters
-    getDevices() {
-        return this.deviceList;
-    }
-    getScenes() {
-        return this.sceneList;
-    }
-    getNode(nodeId) {
-        return this.nodeConfigs.get(nodeId);
-    }
-    log(...args) {
-        if (this.debug) {
-            console.log(...args);
+    sendCommand(nodeId, type, args, callback) {
+        if (this.ws.readyState === WebSocket.OPEN) {
+            const command = {
+                version: 1,
+                client_id: this.clientId,
+                type,
+                action: type,
+                node_id: nodeId,
+                args,
+            };
+            // biome-ignore lint/suspicious/noExplicitAny: Backward compatibility for mock server
+            command.request = { type };
+            if (callback) {
+                this.commandCallbacks.set(type, callback);
+            }
+            this.ws.send(JSON.stringify(command));
+            this.log(`Sent command: ${type}`);
+        }
+        else {
+            this.pendingQueue.push({ nodeId, type, args, callback });
+            this.log(`Queued command (socket not open yet): ${type}`);
         }
     }
     flushPending() {
@@ -401,6 +462,34 @@ class LightController {
             this.sendCommand(p.nodeId, p.type, p.args, p.callback);
         }
     }
+    isLightNodeId(nodeId) {
+        const lightPattern = /^[A-Z0-9]+-[A-Z0-9]+$/i;
+        return lightPattern.test(nodeId);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    log(...args) {
+        if (this.debug) {
+            console.log(...args);
+        }
+    }
+    // Getters & Public Utilities
+    getWebSocket() {
+        return this.ws;
+    }
+    setClientId(clientId) {
+        this.clientId = clientId;
+    }
+    getDevices() {
+        return this.deviceList;
+    }
+    getScenes() {
+        return this.sceneList;
+    }
+    getNode(nodeId) {
+        return this.nodeConfigs.get(nodeId);
+    }
 }
 export default LightController;
 //# sourceMappingURL=lightControl.js.map