amaran-light-cli 1.10.0 → 1.12.0

package/dist/deviceControl/bleHttpControl.js

@@ -0,0 +1,753 @@
+import { z } from 'zod';
+import { FanStateSchema, FanStatesSchema } from '../ble/fan.js';
+import { parseFanMode, validateFanRpm } from '../ble/telink.js';
+const DEFAULT_BLE_URL = 'http://localhost:2708';
+const REQUEST_TIMEOUT_MS = 60_000;
+const UNSUPPORTED_MESSAGE = 'Command is not supported by the BLE backend';
+export default class BleHttpController {
+    baseUrl;
+    apiKey;
+    devices = [];
+    features = {};
+    constructor(baseUrl = DEFAULT_BLE_URL, apiKey) {
+        this.baseUrl = trimTrailingSlashes(baseUrl);
+        this.apiKey = apiKey;
+    }
+    static async connect(baseUrl, apiKey) {
+        const controller = new BleHttpController(baseUrl, apiKey);
+        await controller.refreshDevices();
+        return controller;
+    }
+    async disconnect() {
+        return;
+    }
+    getDevices() {
+        return this.devices;
+    }
+    getFixtureList(callback) {
+        this.getDeviceList(callback);
+    }
+    getDeviceList(callback) {
+        this.refreshDevices()
+            .then(() => callback?.(true, 'OK', { data: this.devices }))
+            .catch((error) => callback?.(false, error.message));
+    }
+    async getHealth(callback) {
+        try {
+            const response = await this.request('/', { method: 'GET' });
+            if (response.ok !== true)
+                throw new Error(response.error || 'BLE backend returned an error');
+            callback?.(true, 'OK', { data: response });
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    turnLightOn(nodeId, callback) {
+        return this.postLightCommand(nodeId, 'on', undefined, callback);
+    }
+    turnLightOff(nodeId, callback) {
+        return this.postLightCommand(nodeId, 'off', undefined, callback);
+    }
+    async turnOnAllLights(callback) {
+        await this.postEachLightCommand('on', {}, callback);
+    }
+    async turnOffAllLights(callback) {
+        await this.postEachLightCommand('off', {}, callback);
+    }
+    setIntensity(nodeId, intensity, callback) {
+        return this.postLightCommand(nodeId, 'brightness', { value: this.apiIntensityToPercent(intensity) }, callback);
+    }
+    async setIntensityForAllLights(intensity, callback) {
+        await this.postEachLightCommand('brightness', { value: this.apiIntensityToPercent(intensity) }, callback);
+    }
+    setCCT(nodeId, cct, intensity, callback) {
+        return this.postLightCommand(nodeId, 'cct', this.cctBody(cct, intensity), callback);
+    }
+    async setAutomaticCCT(nodeId, cct, intensity, callback) {
+        if (!this.features.automaticCct) {
+            await this.setCCT(nodeId, cct, intensity, callback);
+            return;
+        }
+        try {
+            const response = await this.request(`/lights/${encodeURIComponent(nodeId)}/auto-cct`, {
+                method: 'POST',
+                body: JSON.stringify(this.cctBody(cct, intensity)),
+            });
+            if (response.ok !== true)
+                throw new Error(response.error || 'Automatic CCT failed');
+            const result = z
+                .discriminatedUnion('skipped', [
+                z.object({
+                    skipped: z.literal(true),
+                    reason: z.enum(['manual-override', 'light-off', 'thermal-protection', 'stopped-cooling']),
+                }),
+                z.object({ skipped: z.literal(false), state: z.unknown() }),
+            ])
+                .parse(response.result);
+            if (!result.skipped && response.verified !== true)
+                throw new Error('Automatic CCT was not verified');
+            if (!result.skipped) {
+                const state = this.stateRecord(result.state);
+                if (state.mode !== 'cct' || typeof state.cct !== 'number')
+                    throw new Error('Automatic CCT returned invalid state');
+            }
+            callback?.(true, result.skipped ? `Skipped: ${result.reason}` : 'OK', result);
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    overrides(targets, minutes, callback) {
+        return this.libraryRequest('/overrides', 'POST', { targets, ...(minutes === undefined ? {} : { minutes }) }, callback);
+    }
+    getProductInfo(nodeId, callback) {
+        return this.libraryRequest(`/lights/${encodeURIComponent(nodeId)}/info`, 'GET', undefined, callback);
+    }
+    renameGroup(groupId, name, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}/rename`, 'POST', { name }, callback);
+    }
+    getGroup(groupId, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}`, 'GET', undefined, callback);
+    }
+    nativeGroup(groupId, action, address, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}/native`, 'POST', { action, ...(address === undefined ? {} : { address }) }, callback);
+    }
+    inspectMesh(callback) {
+        return this.libraryRequest('/mesh/inspect', 'GET', undefined, callback);
+    }
+    discoverUnprovisioned(callback) {
+        return this.libraryRequest('/mesh/discover', 'GET', undefined, callback);
+    }
+    importDeviceKeys(database, callback) {
+        return this.libraryRequest('/mesh/keys', 'POST', { database }, callback);
+    }
+    importDesktop(database, options, callback) {
+        return this.libraryRequest('/desktop/import', 'POST', { database, ...options }, callback);
+    }
+    startProgram(program, callback) {
+        return this.libraryRequest('/programs', 'POST', program, callback);
+    }
+    getPrograms(id, callback) {
+        return this.libraryRequest(id ? `/programs/${encodeURIComponent(id)}` : '/programs', 'GET', undefined, callback);
+    }
+    stopProgram(id, callback) {
+        return this.libraryRequest(`/programs/${encodeURIComponent(id)}`, 'DELETE', undefined, callback);
+    }
+    programSample(id, sample, callback) {
+        return this.libraryRequest(`/programs/${encodeURIComponent(id)}/sample`, 'POST', sample, callback);
+    }
+    updateSaved(collection, key, name, callback) {
+        return this.libraryRequest(`/library/${collection}/${encodeURIComponent(key)}`, 'POST', { ...(name === undefined ? {} : { name }) }, callback);
+    }
+    replaceSaved(collection, key, name, keys, callback) {
+        return this.libraryRequest(`/library/${collection}/${encodeURIComponent(key)}`, 'POST', { ...(name === undefined ? {} : { name }), ...(keys === undefined ? {} : { keys }) }, callback);
+    }
+    saveSaved(collection, name, keys, callback) {
+        return this.libraryRequest(`/library/${collection}`, 'POST', { name, ...(keys === undefined ? {} : { keys }) }, callback);
+    }
+    getSaved(collection, key, callback) {
+        return this.libraryRequest(`/library/${collection}/${encodeURIComponent(key)}`, 'GET', undefined, callback);
+    }
+    transition(targets, action, args, seconds, callback) {
+        return this.runCommand('/transition', { targets, action, args, seconds }, callback);
+    }
+    transitionScene(key, seconds, callback) {
+        return this.recallSaved('scenes', key, { seconds }, callback);
+    }
+    recallSaved(collection, key, options, callback) {
+        return this.runCommand(`/library/${collection}/${encodeURIComponent(key)}/recall`, options, callback);
+    }
+    async setCCTAndIntensityForAllLights(cct, intensity, callback) {
+        await this.postEachLightCommand('cct', this.cctBody(cct, intensity), callback);
+    }
+    setHSI(nodeId, hue, sat, intensity, cct, gm, callback) {
+        if (cct !== undefined || gm !== undefined) {
+            callback?.(false, 'The 150c supports basic HSI, not advanced HSI CCT/G/M adjustments');
+            return;
+        }
+        return this.postLightCommand(nodeId, 'hsi', { brightness: this.apiIntensityToPercent(intensity), hue, saturation: sat }, callback);
+    }
+    async setHSIForAllLights(hue, sat, intensity, cct, gm, callback) {
+        if (cct !== undefined || gm !== undefined) {
+            callback?.(false, 'The 150c supports basic HSI, not advanced HSI CCT/G/M adjustments');
+            return;
+        }
+        await this.postEachLightCommand('hsi', { brightness: this.apiIntensityToPercent(intensity), hue, saturation: sat }, callback);
+    }
+    async getNodeConfig(nodeId, callback) {
+        const device = this.devices.find((entry) => entry.node_id === nodeId || entry.id === nodeId);
+        if (!device) {
+            callback?.(false, `Device "${nodeId}" not found`);
+            return;
+        }
+        const capabilities = typeof device.capabilities === 'object' && device.capabilities ? device.capabilities : {};
+        if (this.features.state) {
+            await this.readState(nodeId, (success, message, state) => {
+                callback?.(success, message, success ? { data: { ...device, ...capabilities, ...z.record(z.unknown()).parse(state) } } : undefined);
+            }, true);
+        }
+        else {
+            callback?.(true, 'OK', { data: { ...device, ...capabilities } });
+        }
+    }
+    getSceneList(callback) {
+        return this.libraryRequest('/library/scenes', 'GET', undefined, callback);
+    }
+    getLightSleepStatus(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    getIntensity(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    getCCT(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    getHSI(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    async toggleAllLights(callback) {
+        if (!this.features.toggle) {
+            this.unsupported(callback);
+            return;
+        }
+        await this.postEachLightCommand('toggle', {}, callback);
+    }
+    toggleLight(nodeId, callback) {
+        if (!this.features.toggle) {
+            this.unsupported(callback);
+            return;
+        }
+        return this.postLightCommand(nodeId, 'toggle', {}, callback);
+    }
+    incrementIntensity(nodeId, delta, callback) {
+        return this.postLightCommand(nodeId, 'increment-brightness', { delta: delta / 10 }, callback);
+    }
+    async incrementIntensityForAllLights(delta, callback) {
+        await this.postEachLightCommand('increment-brightness', { delta: delta / 10 }, callback);
+    }
+    incrementCCT(nodeId, delta, intensity, callback) {
+        return this.postLightCommand(nodeId, 'increment-cct', { delta, ...this.optionalBrightness(intensity) }, callback);
+    }
+    async incrementCCTForAllLights(delta, intensity, callback) {
+        await this.postEachLightCommand('increment-cct', { delta, ...this.optionalBrightness(intensity) }, callback);
+    }
+    setColor(nodeId, color, intensity, callback) {
+        return this.postLightCommand(nodeId, 'color', { color, ...this.optionalBrightness(intensity) }, callback);
+    }
+    async setColorForAllLights(color, intensity, callback) {
+        await this.postEachLightCommand('color', { color, ...this.optionalBrightness(intensity) }, callback);
+    }
+    getRGB(_nodeId, callback) {
+        this.unsupported(callback);
+    }
+    setRGB(_nodeId, _r, _g, _b, _intensity, callback) {
+        this.unsupported(callback);
+    }
+    getXY(_nodeId, callback) {
+        this.unsupported(callback);
+    }
+    setXY(_nodeId, _x, _y, _intensity, callback) {
+        this.unsupported(callback);
+    }
+    getSystemEffect(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    getSystemEffectList(callback) {
+        return this.libraryRequest('/effects', 'GET', undefined, callback);
+    }
+    setSystemEffect(nodeId, effectType, intensity, callback) {
+        return this.postLightCommand(nodeId, 'effect', { name: effectType, ...this.optionalBrightness(intensity) }, callback);
+    }
+    async setSystemEffectForAllLights(effectType, intensity, callback) {
+        await this.postEachLightCommand('effect', { name: effectType, ...this.optionalBrightness(intensity) }, callback);
+    }
+    getEffect(nodeId, callback) {
+        return this.readState(nodeId, callback);
+    }
+    setEffect(nodeId, effectName, args, callback) {
+        return this.postLightCommand(nodeId, 'effect', { ...args, name: effectName }, callback);
+    }
+    setEffectSpeed(nodeId, speed, callback) {
+        return this.postLightCommand(nodeId, 'effect-speed', { value: speed }, callback);
+    }
+    setEffectAnimationSpeed(nodeId, speed, callback) {
+        return this.postLightCommand(nodeId, 'effect-animation-speed', { value: speed }, callback);
+    }
+    setEffectIntensity(nodeId, intensity, callback) {
+        return this.postLightCommand(nodeId, 'effect-intensity', { value: this.apiIntensityToPercent(intensity) }, callback);
+    }
+    getFanMode(nodeId, callback) {
+        return this.fanValue(nodeId, 'mode', callback);
+    }
+    async getFanInfo(nodeId, callback) {
+        if (nodeId.startsWith('group:'))
+            return this.fanStates([nodeId], undefined, callback);
+        if (!this.features.fan) {
+            this.unsupported(callback);
+            return;
+        }
+        try {
+            const response = await this.request(`/lights/${encodeURIComponent(nodeId)}/fan`, {
+                method: 'GET',
+            });
+            if (response.ok !== true)
+                throw new Error(response.error || 'BLE fan query failed');
+            const state = FanStateSchema.parse(response.result);
+            callback?.(true, 'OK', state);
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    setFanMode(nodeId, mode, callback) {
+        if (nodeId.startsWith('group:'))
+            return this.fanStates([nodeId], mode, callback);
+        return this.postLightCommand(nodeId, 'fan', { mode }, callback);
+    }
+    async fanStates(targets, mode, callback, rpm) {
+        try {
+            if (mode === undefined && rpm !== undefined)
+                throw new Error('RPM requires manual fan mode');
+            if (mode !== undefined)
+                validateFanRpm(parseFanMode(mode), rpm);
+        }
+        catch (error) {
+            callback?.(false, error.message);
+            return;
+        }
+        if (rpm !== undefined && !this.features.fanManualRpm) {
+            callback?.(false, 'Manual RPM control requires the updated BLE daemon');
+            return;
+        }
+        if (!this.features.fanTargets) {
+            if (targets !== 'all' && targets.length === 1 && !targets[0].startsWith('group:')) {
+                const wrap = (ok, message, state) => {
+                    if (!ok) {
+                        callback?.(false, message);
+                        return;
+                    }
+                    const parsed = FanStateSchema.safeParse(state);
+                    if (!parsed.success) {
+                        callback?.(false, parsed.error.message);
+                        return;
+                    }
+                    callback?.(true, message, { states: { [targets[0]]: parsed.data } });
+                };
+                if (mode !== undefined) {
+                    await this.postLightCommand(targets[0], 'fan', { mode, ...(rpm === undefined ? {} : { rpm }) }, wrap);
+                }
+                else {
+                    await this.getFanInfo(targets[0], wrap);
+                }
+            }
+            else
+                callback?.(false, 'Fan group/all control requires the updated BLE daemon');
+            return;
+        }
+        const response = await this.executeCommand('/fans', {
+            targets,
+            ...(mode === undefined ? {} : { mode }),
+            ...(rpm === undefined ? {} : { rpm }),
+        });
+        if (!response.success) {
+            callback?.(false, response.message);
+            return;
+        }
+        const parsed = FanStatesSchema.safeParse(response.data);
+        if (!parsed.success) {
+            callback?.(false, parsed.error.message);
+            return;
+        }
+        callback?.(true, 'OK', parsed.data);
+    }
+    getFanSpeed(nodeId, callback) {
+        return this.fanValue(nodeId, 'speed', callback);
+    }
+    setFanSpeed(nodeId, speed, callback) {
+        return this.fanStates([nodeId], 'manual', callback, speed);
+    }
+    getPresetList(callback) {
+        return this.libraryRequest('/library/presets', 'GET', undefined, callback);
+    }
+    recallPreset(nodeId, presetId, callback) {
+        return this.recallSaved('presets', presetId, { target: nodeId }, callback);
+    }
+    setPreset(nodeId, presetId, callback) {
+        return this.recallPreset(nodeId, presetId, callback);
+    }
+    getQuickshotList(callback) {
+        return this.libraryRequest('/library/quickshots', 'GET', undefined, callback);
+    }
+    setQuickshot(quickshotId, callback) {
+        return this.recallSaved('quickshots', quickshotId, {}, callback);
+    }
+    saveScene(name, callback) {
+        return this.libraryRequest('/library/scenes', 'POST', { name }, callback);
+    }
+    deleteScene(sceneId, callback) {
+        return this.libraryRequest(`/library/scenes/${encodeURIComponent(sceneId)}`, 'DELETE', undefined, callback);
+    }
+    recallScene(sceneId, callback) {
+        return this.runCommand(`/library/scenes/${encodeURIComponent(sceneId)}/recall`, {}, callback);
+    }
+    updateScene(sceneId, name, callback) {
+        return this.libraryRequest(`/library/scenes/${encodeURIComponent(sceneId)}`, 'POST', { name }, callback);
+    }
+    getGroupList(callback) {
+        return this.libraryRequest('/groups', 'GET', undefined, callback);
+    }
+    createGroup(name, callback) {
+        return this.libraryRequest('/groups', 'POST', { name }, callback);
+    }
+    deleteGroup(groupId, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}`, 'DELETE', undefined, callback);
+    }
+    addToGroup(groupId, nodeId, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}/members`, 'POST', { member: nodeId }, callback);
+    }
+    removeFromGroup(groupId, nodeId, callback) {
+        return this.libraryRequest(`/groups/${encodeURIComponent(groupId)}/members`, 'POST', { member: nodeId, remove: true }, callback);
+    }
+    setGM(nodeId, value, callback) {
+        return this.postLightCommand(nodeId, 'gm', { value }, callback);
+    }
+    stopEffect(nodeId, callback) {
+        return this.postLightCommand(nodeId, 'effect-stop', {}, callback);
+    }
+    triggerEffect(nodeId, callback) {
+        return this.postLightCommand(nodeId, 'effect-trigger', {}, callback);
+    }
+    batch(targets, action, args, broadcast, callback) {
+        return this.runCommand('/batch', { targets, action, args, broadcast }, callback);
+    }
+    fade(targets, brightness, seconds, callback) {
+        return this.runCommand('/fade', { targets, brightness, seconds }, callback);
+    }
+    savePreset(nodeId, name, callback) {
+        return this.libraryRequest('/library/presets', 'POST', { name, keys: [nodeId] }, callback);
+    }
+    saveQuickshot(name, callback) {
+        return this.libraryRequest('/library/quickshots', 'POST', { name }, callback);
+    }
+    deleteSaved(collection, key, callback) {
+        return this.libraryRequest(`/library/${collection}/${encodeURIComponent(key)}`, 'DELETE', undefined, callback);
+    }
+    getDeviceInfo(nodeId, callback) {
+        this.getNodeConfig(nodeId, callback);
+    }
+    updateFirmware(_nodeId, callback) {
+        this.unsupported(callback);
+    }
+    async refreshDevices() {
+        const response = await this.request('/', { method: 'GET' });
+        if (response.ok !== true) {
+            throw new Error(response.error || 'BLE backend returned an error');
+        }
+        const lights = z
+            .array(z
+            .object({
+            key: z.string().min(1),
+            name: z.string().min(1),
+            mac: z.string().optional(),
+            address: z.number().optional(),
+            model: z.string().optional(),
+            capabilities: z.record(z.unknown()).optional(),
+        })
+            .passthrough())
+            .parse(response.lights);
+        this.features = z.record(z.boolean()).parse(response.features ?? {});
+        this.devices = lights.map((light) => ({
+            ...light,
+            id: light.key,
+            node_id: light.key,
+            device_name: light.name,
+            name: light.name,
+            device_type: 'ble-light',
+            backend: 'ble',
+        }));
+        const groups = z
+            .array(z.object({ id: z.string(), name: z.string(), members: z.array(z.string()) }))
+            .parse(response.groups ?? []);
+        this.devices.push(...groups.map((group) => ({
+            ...group,
+            node_id: group.id,
+            device_name: group.name,
+            device_type: 'ble-group',
+            backend: 'ble',
+        })));
+    }
+    async postLightCommand(nodeId, command, body, callback) {
+        if (!this.supportsCommand(command)) {
+            this.unsupported(callback);
+            return;
+        }
+        await this.runCommand(`/lights/${encodeURIComponent(nodeId)}/${command}`, body ?? {}, callback);
+    }
+    async postEachLightCommand(command, body, callback) {
+        if (!this.supportsCommand(command)) {
+            this.unsupported(callback);
+            return;
+        }
+        if (this.features.batch && command !== 'toggle') {
+            await this.batch('all', command, body, false, callback);
+            return;
+        }
+        const targets = this.devices.flatMap((device) => {
+            if (device.device_type === 'ble-group')
+                return [];
+            const nodeId = typeof device.node_id === 'string' ? device.node_id : typeof device.id === 'string' ? device.id : undefined;
+            if (!nodeId)
+                return [];
+            return [
+                {
+                    nodeId,
+                    name: String(device.device_name || device.name || device.id || device.node_id || 'Unknown'),
+                },
+            ];
+        });
+        if (targets.length === 0) {
+            callback?.(false, 'No BLE lights available');
+            return;
+        }
+        const failures = [];
+        for (const target of targets) {
+            const result = await this.executeCommand(`/lights/${encodeURIComponent(target.nodeId)}/${command}`, body);
+            if (!result.success) {
+                failures.push(`${String(target.name)}: ${result.message}`);
+            }
+        }
+        if (failures.length > 0) {
+            callback?.(false, failures.join('; '));
+            return;
+        }
+        callback?.(true, 'OK');
+    }
+    async runCommand(path, body, callback) {
+        const result = await this.executeCommand(path, body);
+        callback?.(result.success, result.message, result.data);
+    }
+    async libraryRequest(path, method, body, callback) {
+        const feature = path.startsWith('/programs')
+            ? 'programs'
+            : path === '/desktop/import'
+                ? 'desktopImport'
+                : path.startsWith('/mesh/')
+                    ? 'meshConfig'
+                    : path === '/effects'
+                        ? 'effects'
+                        : path === '/overrides'
+                            ? 'automaticCct'
+                            : path.startsWith('/lights/') && path.endsWith('/info')
+                                ? 'productInfo'
+                                : 'library';
+        if (!this.features[feature]) {
+            this.unsupported(callback);
+            return;
+        }
+        try {
+            const response = await this.request(path, {
+                method,
+                ...(body ? { body: JSON.stringify(body) } : {}),
+            });
+            if (response.ok !== true)
+                throw new Error(response.error || 'BLE library operation failed');
+            callback?.(true, 'OK', { data: response.result });
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    async fanValue(nodeId, field, callback) {
+        if (nodeId.startsWith('group:')) {
+            callback?.(false, 'A group has separate fan states; use fan info for per-fixture telemetry');
+            return;
+        }
+        if (!this.features.fan) {
+            this.unsupported(callback);
+            return;
+        }
+        try {
+            const response = await this.request(`/lights/${encodeURIComponent(nodeId)}/fan`, {
+                method: 'GET',
+            });
+            if (response.ok !== true)
+                throw new Error(response.error || 'BLE fan query failed');
+            const state = FanStateSchema.parse(response.result);
+            callback?.(true, 'OK', state[field]);
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    async executeCommand(path, body) {
+        const feature = path === '/transition'
+            ? 'transitions'
+            : path === '/batch'
+                ? 'batch'
+                : path === '/fade'
+                    ? 'fade'
+                    : path === '/fans'
+                        ? 'fanTargets'
+                        : path.startsWith('/library/')
+                            ? 'library'
+                            : undefined;
+        if (feature && !this.features[feature])
+            return { success: false, message: UNSUPPORTED_MESSAGE };
+        try {
+            const response = await this.request(path, {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+            if (response.ok !== true) {
+                return { success: false, message: response.error || 'BLE backend returned an error' };
+            }
+            if (this.features.verifiedCommands && response.verified !== true) {
+                return { success: false, message: 'BLE daemon did not verify this command' };
+            }
+            return { success: true, message: 'OK', data: response.result };
+        }
+        catch (error) {
+            return { success: false, message: error.message };
+        }
+    }
+    async request(path, init) {
+        const headers = { ...(init.body ? { 'content-type': 'application/json' } : {}) };
+        if (this.apiKey) {
+            headers.authorization = `Bearer ${this.apiKey}`;
+        }
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(url, { ...init, headers, signal: controller.signal });
+            const raw = await response.text();
+            const data = this.parseResponseBody(response.status === 204 && !raw ? '{"ok":true}' : raw, response.status, url);
+            if (!response.ok)
+                throw new Error(data.error || `BLE backend HTTP ${response.status}`);
+            return data;
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw new Error(`BLE backend request timed out after ${REQUEST_TIMEOUT_MS}ms: ${url}`);
+            }
+            if (error instanceof TypeError)
+                throw new Error(this.formatRequestError(url, error));
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    formatRequestError(url, error) {
+        if (error instanceof Error) {
+            if (error instanceof TypeError && error.message === 'fetch failed') {
+                return `Unable to reach BLE backend at ${url}. Make sure the BLE service is running.`;
+            }
+            return `Unable to reach BLE backend at ${url}: ${error.message}`;
+        }
+        return `Unable to reach BLE backend at ${url}`;
+    }
+    parseResponseBody(raw, status, url) {
+        if (!raw) {
+            throw new Error(`Empty JSON response from BLE backend (${status}) at ${url}`);
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON response from BLE backend (${status}) at ${url}: ${error.message}`);
+        }
+    }
+    cctBody(cct, intensity) {
+        return {
+            kelvin: cct,
+            ...(intensity !== undefined ? { brightness: this.apiIntensityToPercent(intensity) } : {}),
+        };
+    }
+    optionalBrightness(intensity) {
+        return intensity === undefined ? {} : { brightness: this.apiIntensityToPercent(intensity) };
+    }
+    supportsCommand(command) {
+        const feature = {
+            gm: 'gm',
+            fan: 'fan',
+            color: 'color',
+            effect: 'effects',
+            'effect-speed': 'effects',
+            'effect-animation-speed': 'effects',
+            'effect-intensity': 'effects',
+            'effect-stop': 'effects',
+            'effect-trigger': 'effectTrigger',
+            'increment-cct': 'relative',
+            'increment-brightness': 'relative',
+        };
+        return !Object.hasOwn(feature, command) || this.features[feature[command]] === true;
+    }
+    apiIntensityToPercent(intensity) {
+        if (!Number.isFinite(intensity) || intensity < 0 || intensity > 1000)
+            throw new Error('Intensity must be between 0 and 1000');
+        return intensity / 10;
+    }
+    stateRecord(value) {
+        const state = z
+            .object({
+            sleep: z.boolean(),
+            intensity: z.number().min(0).max(1000),
+            mode: z.enum(['cct', 'hsi', 'effect']),
+            cct: z.number().optional(),
+            gm: z.number().optional(),
+            hue: z.number().optional(),
+            sat: z.number().optional(),
+            effect: z.string().optional(),
+            frequency: z.number().optional(),
+            speed: z.number().optional(),
+            palette: z.number().optional(),
+            observedAt: z.string(),
+        })
+            .parse(value);
+        return { ...state, work_mode: state.mode, effect_type: state.effect, effect_name: state.effect };
+    }
+    async readState(nodeId, callback, allowGroup = false) {
+        if (!this.features.state) {
+            callback?.(false, 'State readback is not available from this BLE daemon');
+            return;
+        }
+        const group = this.devices.find((device) => device.node_id === nodeId)?.device_type === 'ble-group';
+        if (group && !allowGroup) {
+            callback?.(false, 'A group has separate fixture states; use status <group> to inspect its members');
+            return;
+        }
+        try {
+            const response = await this.request(`/lights/${encodeURIComponent(nodeId)}/state`, {
+                method: 'GET',
+            });
+            if (response.ok !== true)
+                throw new Error(response.error || 'BLE state query failed');
+            if (group) {
+                const members = Object.fromEntries(Object.entries(z.record(z.unknown()).parse(response.result)).map(([key, value]) => {
+                    const device = this.devices.find((entry) => entry.node_id === key);
+                    const caps = z.record(z.unknown()).parse(device?.capabilities ?? {});
+                    return [key, { ...caps, ...this.stateRecord(value) }];
+                }));
+                callback?.(true, 'OK', { work_mode: 'group', member_states: members });
+            }
+            else
+                callback?.(true, 'OK', this.stateRecord(response.result));
+        }
+        catch (error) {
+            callback?.(false, error.message);
+        }
+    }
+    unsupported(callback) {
+        callback?.(false, UNSUPPORTED_MESSAGE);
+    }
+}
+export function trimTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value[end - 1] === '/') {
+        end--;
+    }
+    return value.slice(0, end);
+}
+//# sourceMappingURL=bleHttpControl.js.map