@smarthome.exchange/integrations 0.1.0 → 1.0.0

package/dist_ts/integrations/hue/hue.classes.client.js

@@ -1,28 +1,283 @@
+import * as plugins from '../../plugins.js';
+import { hueContentType, hueUuid, normalizeHueConfig, parseHueEnvelope, parseHueEvents, parseHueResources, validateHuePatch } from './hue.validation.js';
+class HueEventDecoder {
+    #decoder = new TextDecoder('utf-8', { fatal: true });
+    #buffer = '';
+    #data = [];
+    #frameBytes = 0;
+    #skipLf = false;
+    feed(chunkArg) {
+        this.#buffer += this.#decoder.decode(chunkArg, { stream: true });
+        const events = [];
+        while (this.#buffer.length) {
+            if (this.#skipLf) {
+                if (this.#buffer.startsWith('\n'))
+                    this.#buffer = this.#buffer.slice(1);
+                this.#skipLf = false;
+            }
+            const separator = this.#buffer.search(/[\r\n]/);
+            if (separator === -1)
+                break;
+            const line = this.#buffer.slice(0, separator);
+            this.#skipLf = this.#buffer[separator] === '\r';
+            this.#buffer = this.#buffer.slice(separator + 1);
+            this.#frameBytes += Buffer.byteLength(line);
+            this.assertBounded();
+            if (line === '') {
+                if (this.#data.length)
+                    events.push(...parseHueEvents(JSON.parse(this.#data.join('\n'))));
+                this.#data = [];
+                this.#frameBytes = 0;
+            }
+            else if (line.startsWith('data:'))
+                this.#data.push(line.slice(5).replace(/^ /, ''));
+        }
+        this.assertBounded();
+        return events;
+    }
+    assertBounded() {
+        if (this.#frameBytes + Buffer.byteLength(this.#buffer) > 1_048_576)
+            throw new Error('Hue event stream frame exceeds its size limit.');
+    }
+}
 export class HueClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async getResources() {
-        return this.config.resources ?? {
-            bridge: {
-                id: this.config.bridgeId,
-                productData: {
-                    manufacturerName: 'Signify',
-                    productName: 'Philips Hue Bridge',
-                },
-                metadata: {
-                    name: 'Hue Bridge',
-                },
-            },
-            devices: [],
-            lights: [],
+    setupSignal;
+    #config;
+    #agent;
+    #lifetime = new AbortController();
+    #connections = new Set();
+    #destroyPromise;
+    #streamCount = 0;
+    #healthy = false;
+    #eventFailure = false;
+    constructor(configArg, setupSignal) {
+        this.setupSignal = setupSignal;
+        this.#config = normalizeHueConfig(configArg);
+        this.#agent = new plugins.https.Agent({ keepAlive: false, maxSockets: 3, maxTotalSockets: 3 });
+        if (setupSignal?.aborted)
+            this.#lifetime.abort();
+        else
+            setupSignal?.addEventListener('abort', this.abortSetup, { once: true });
+    }
+    isHealthy() {
+        return !this.#lifetime.signal.aborted && this.#healthy && !this.#eventFailure;
+    }
+    async getResources(abortSignalArg) {
+        try {
+            const data = parseHueEnvelope(await this.request('GET', '/clip/v2/resource', undefined, abortSignalArg));
+            const resources = parseHueResources(data, this.#config.bridgeId);
+            this.#healthy = true;
+            return resources;
+        }
+        catch (error) {
+            this.#healthy = false;
+            throw error;
+        }
+    }
+    async setLightState(lightIdArg, stateArg, abortSignalArg) {
+        if (!hueUuid(lightIdArg))
+            throw new Error('Hue light target must be a resource UUID.');
+        validateHuePatch(stateArg);
+        const lightId = lightIdArg.toLowerCase();
+        const state = { ...stateArg };
+        const snapshot = await this.getResources(abortSignalArg);
+        const light = snapshot.lights.find((lightArg) => lightArg.id === lightId);
+        if (!light || !light.available)
+            throw new Error('Hue light target is unknown or unavailable.');
+        if (state.brightness !== undefined && !light.dimming)
+            throw new Error('Hue light does not support brightness.');
+        const body = { ...(state.on === undefined ? {} : { on: { on: state.on } }),
+            ...(state.brightness === undefined ? {} : { dimming: { brightness: state.brightness } }) };
+        const data = parseHueEnvelope(await this.request('PUT', `/clip/v2/resource/light/${lightId}`, body, abortSignalArg));
+        if (data.length !== 1)
+            throw new Error('Hue write acknowledgement does not identify the target light.');
+        const acknowledgement = data[0];
+        if (!acknowledgement || typeof acknowledgement !== 'object' || Array.isArray(acknowledgement)
+            || !('rid' in acknowledgement) || typeof acknowledgement.rid !== 'string' || acknowledgement.rid.toLowerCase() !== lightId
+            || !('rtype' in acknowledgement) || acknowledgement.rtype !== 'light') {
+            throw new Error('Hue write acknowledgement does not identify the target light.');
+        }
+    }
+    async subscribeToEvents(handlerArg, onErrorArg, abortSignalArg) {
+        this.assertOpen(abortSignalArg);
+        if (this.#streamCount >= 2)
+            throw new Error('Hue event subscription limit reached.');
+        this.#streamCount++;
+        let resolveClosed = () => { };
+        const closed = new Promise((resolveArg) => { resolveClosed = resolveArg; });
+        const abort = new AbortController();
+        const signal = AbortSignal.any([this.#lifetime.signal, abort.signal, ...(abortSignalArg ? [abortSignalArg] : [])]);
+        let active = true;
+        signal.addEventListener('abort', () => { active = false; }, { once: true });
+        let established = false;
+        let request;
+        const connection = { closed, cancel: () => { active = false; abort.abort(); request?.destroy(); } };
+        this.#connections.add(connection);
+        const decoder = new HueEventDecoder();
+        let failureReported = false;
+        const fail = (errorArg) => {
+            if (!active || failureReported)
+                return;
+            failureReported = true;
+            this.#eventFailure = true;
+            active = false;
+            abort.abort();
+            request?.destroy();
+            if (established)
+                onErrorArg(errorArg);
         };
+        const ready = new Promise((resolveArg, rejectArg) => {
+            const deadline = setTimeout(() => {
+                fail(new Error('Hue event stream connection timed out.'));
+                rejectArg(new Error('Hue event stream connection timed out.'));
+            }, this.#config.requestTimeoutMs);
+            const settleFailure = (errorArg) => {
+                clearTimeout(deadline);
+                if (!established)
+                    rejectArg(errorArg);
+                fail(errorArg);
+            };
+            request = plugins.https.request(this.requestOptions('GET', '/eventstream/clip/v2', signal, {
+                accept: 'text/event-stream', 'cache-control': 'no-cache',
+            }), (responseArg) => {
+                if (responseArg.statusCode !== 200 || !hueContentType(responseArg.headers['content-type'], 'text/event-stream')) {
+                    responseArg.destroy();
+                    settleFailure(new Error('Hue event stream rejected or returned an invalid content type.'));
+                    return;
+                }
+                clearTimeout(deadline);
+                established = true;
+                this.#eventFailure = false;
+                resolveArg();
+                responseArg.on('data', (chunkArg) => {
+                    if (!active)
+                        return;
+                    try {
+                        for (const event of decoder.feed(chunkArg)) {
+                            if (active)
+                                handlerArg(event);
+                        }
+                    }
+                    catch {
+                        settleFailure(new Error('Hue event stream contains invalid or oversized data.'));
+                    }
+                });
+                responseArg.once('error', () => settleFailure(new Error('Hue event stream transport failed.')));
+                responseArg.once('end', () => settleFailure(new Error('Hue event stream ended.')));
+                responseArg.once('aborted', () => settleFailure(new Error('Hue event stream was interrupted.')));
+            });
+            request.once('error', () => settleFailure(new Error('Hue event stream transport failed.')));
+            request.once('close', () => {
+                clearTimeout(deadline);
+                this.#connections.delete(connection);
+                this.#streamCount--;
+                resolveClosed();
+                if (!established)
+                    rejectArg(new Error('Hue event subscription was cancelled.'));
+            });
+            request.end();
+        });
+        try {
+            await ready;
+        }
+        catch (error) {
+            connection.cancel();
+            if (!request) {
+                this.#connections.delete(connection);
+                this.#streamCount--;
+                resolveClosed();
+            }
+            await closed;
+            throw error;
+        }
+        return async () => { connection.cancel(); await closed; };
+    }
+    destroy() {
+        if (this.#destroyPromise)
+            return this.#destroyPromise;
+        this.setupSignal?.removeEventListener('abort', this.abortSetup);
+        this.#lifetime.abort();
+        this.#destroyPromise = this.drain();
+        return this.#destroyPromise;
+    }
+    abortSetup = () => { void this.destroy(); };
+    async drain() {
+        const connections = [...this.#connections];
+        for (const connection of connections)
+            connection.cancel();
+        this.#agent.destroy();
+        await Promise.all(connections.map((connectionArg) => connectionArg.closed));
+    }
+    assertOpen(abortSignalArg) {
+        if (this.#lifetime.signal.aborted || abortSignalArg?.aborted)
+            throw new Error('Hue client operation was cancelled or the client is closed.');
+        if (this.#connections.size >= 32)
+            throw new Error('Hue concurrent request limit reached.');
+    }
+    requestOptions(methodArg, pathArg, signalArg, headersArg = {}) {
+        return { hostname: this.#config.host, port: this.#config.port, path: pathArg, method: methodArg,
+            servername: this.#config.bridgeId, ca: this.#config.trustedCa, rejectUnauthorized: true,
+            checkServerIdentity: (_hostnameArg, certificateArg) => plugins.tls.checkServerIdentity(this.#config.bridgeId, certificateArg),
+            signal: signalArg, agent: this.#agent,
+            headers: { 'hue-application-key': this.#config.appKey, accept: 'application/json', ...headersArg } };
     }
-    async setLightState(lightIdArg, stateArg) {
-        void lightIdArg;
-        void stateArg;
+    async request(methodArg, pathArg, bodyArg, abortSignalArg) {
+        this.assertOpen(abortSignalArg);
+        const abort = new AbortController();
+        const signal = AbortSignal.any([this.#lifetime.signal, abort.signal, ...(abortSignalArg ? [abortSignalArg] : [])]);
+        const encoded = bodyArg === undefined ? undefined : JSON.stringify(bodyArg);
+        let request;
+        let resolveClosed = () => { };
+        const closed = new Promise((resolveArg) => { resolveClosed = resolveArg; });
+        const connection = { closed, cancel: () => { abort.abort(); request?.destroy(); } };
+        this.#connections.add(connection);
+        const deadline = setTimeout(() => { abort.abort(); request?.destroy(); }, this.#config.requestTimeoutMs);
+        try {
+            return await new Promise((resolveArg, rejectArg) => {
+                request = plugins.https.request(this.requestOptions(methodArg, pathArg, signal, encoded === undefined ? {} : {
+                    'content-type': 'application/json', 'content-length': String(Buffer.byteLength(encoded)),
+                }), (responseArg) => {
+                    if (responseArg.statusCode !== 200 || !hueContentType(responseArg.headers['content-type'], 'application/json')) {
+                        responseArg.destroy();
+                        rejectArg(new Error(`Hue API request failed with HTTP status ${responseArg.statusCode ?? 0}.`));
+                        return;
+                    }
+                    const chunks = [];
+                    let received = 0;
+                    responseArg.on('data', (chunkArg) => {
+                        received += chunkArg.length;
+                        if (received > 4_194_304) {
+                            responseArg.destroy();
+                            rejectArg(new Error('Hue API response exceeds its size limit.'));
+                        }
+                        else
+                            chunks.push(chunkArg);
+                    });
+                    responseArg.once('end', () => {
+                        try {
+                            resolveArg(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks))));
+                        }
+                        catch {
+                            rejectArg(new Error('Hue API returned invalid JSON.'));
+                        }
+                    });
+                    responseArg.once('aborted', () => rejectArg(new Error('Hue API response was interrupted.')));
+                    responseArg.once('error', () => rejectArg(new Error('Hue API response transport failed.')));
+                });
+                request.once('error', () => rejectArg(new Error('Hue HTTPS request failed or was cancelled.')));
+                request.once('close', () => { this.#connections.delete(connection); resolveClosed(); });
+                request.end(encoded);
+            });
+        }
+        finally {
+            clearTimeout(deadline);
+            connection.cancel();
+            if (!request) {
+                this.#connections.delete(connection);
+                resolveClosed();
+            }
+            await closed;
+        }
     }
-    async destroy() { }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHVlLmNsYXNzZXMuY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL2h1ZS9odWUuY2xhc3Nlcy5jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFNBQVM7SUFDUztJQUE3QixZQUE2QixNQUFrQjtRQUFsQixXQUFNLEdBQU4sTUFBTSxDQUFZO0lBQUcsQ0FBQztJQUU1QyxLQUFLLENBQUMsWUFBWTtRQUN2QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxJQUFJO1lBQzlCLE1BQU0sRUFBRTtnQkFDTixFQUFFLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRO2dCQUN4QixXQUFXLEVBQUU7b0JBQ1gsZ0JBQWdCLEVBQUUsU0FBUztvQkFDM0IsV0FBVyxFQUFFLG9CQUFvQjtpQkFDbEM7Z0JBQ0QsUUFBUSxFQUFFO29CQUNSLElBQUksRUFBRSxZQUFZO2lCQUNuQjthQUNGO1lBQ0QsT0FBTyxFQUFFLEVBQUU7WUFDWCxNQUFNLEVBQUUsRUFBRTtTQUNYLENBQUM7SUFDSixDQUFDO0lBRU0sS0FBSyxDQUFDLGFBQWEsQ0FBQyxVQUFrQixFQUFFLFFBQTZCO1FBQzFFLEtBQUssVUFBVSxDQUFDO1FBQ2hCLEtBQUssUUFBUSxDQUFDO0lBQ2hCLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTyxLQUFtQixDQUFDO0NBQ3pDIn0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hue.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/hue/hue.classes.client.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/hue/hue.classes.configflow.js

@@ -1,24 +1,44 @@
+import { HueClient } from './hue.classes.client.js';
+import { hueBridgeId, normalizeHueConfig, normalizeHueHost } from './hue.validation.js';
 export class HueConfigFlow {
     async start(candidateArg, contextArg) {
         void contextArg;
+        const bridgeId = hueBridgeId(candidateArg.id) ? candidateArg.id : undefined;
+        let host;
+        try {
+            host = normalizeHueHost(candidateArg.host);
+        }
+        catch {
+            host = undefined;
+        }
         return {
-            kind: 'form',
-            title: 'Connect Philips Hue Bridge',
-            description: 'Press the bridge button, then provide the generated app key or paste an existing key.',
+            kind: 'form', title: 'Connect Philips Hue Bridge',
+            description: 'Provide a bridge application key created with the physical link button. For Hue private-CA certificates, provide the trusted Hue CA from the developer portal. Setup verifies the TLS identity and live bridge resources.',
             fields: [
+                ...(!bridgeId ? [{ name: 'bridgeId', label: 'Hue bridge ID', type: 'text', required: true }] : []),
+                ...(!host ? [{ name: 'host', label: 'Bridge hostname or IP address', type: 'text', required: true }] : []),
                 { name: 'appKey', label: 'Hue app key', type: 'password', required: true },
+                { name: 'trustedCa', label: 'Trusted Hue CA certificate (PEM)', type: 'text' },
             ],
-            submit: async (valuesArg) => ({
-                kind: 'done',
-                title: 'Hue bridge configured',
-                config: {
-                    bridgeId: candidateArg.id || 'unknown-hue-bridge',
-                    host: candidateArg.host || 'localhost',
-                    port: candidateArg.port || 443,
-                    appKey: String(valuesArg.appKey || ''),
-                },
-            }),
+            submit: async (valuesArg) => {
+                let client;
+                try {
+                    const config = normalizeHueConfig({ bridgeId: bridgeId ?? valuesArg.bridgeId,
+                        host: host ?? valuesArg.host, port: candidateArg.port ?? 443,
+                        appKey: valuesArg.appKey, trustedCa: valuesArg.trustedCa === '' ? undefined : valuesArg.trustedCa });
+                    client = new HueClient(config);
+                    await client.getResources();
+                    return { kind: 'done', title: 'Hue bridge verified', config };
+                }
+                catch {
+                    return { kind: 'error', title: 'Hue bridge could not be verified',
+                        error: 'Check the bridge ID, HTTPS endpoint, trusted CA and application key. The bridge must support Hue API v2.' };
+                }
+                finally {
+                    await client?.destroy();
+                }
+            },
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHVlLmNsYXNzZXMuY29uZmlnZmxvdy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy9odWUvaHVlLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sYUFBYTtJQUNqQixLQUFLLENBQUMsS0FBSyxDQUFDLFlBQWlDLEVBQUUsVUFBOEI7UUFDbEYsS0FBSyxVQUFVLENBQUM7UUFDaEIsT0FBTztZQUNMLElBQUksRUFBRSxNQUFNO1lBQ1osS0FBSyxFQUFFLDRCQUE0QjtZQUNuQyxXQUFXLEVBQUUsdUZBQXVGO1lBQ3BHLE1BQU0sRUFBRTtnQkFDTixFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUU7YUFDM0U7WUFDRCxNQUFNLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDNUIsSUFBSSxFQUFFLE1BQU07Z0JBQ1osS0FBSyxFQUFFLHVCQUF1QjtnQkFDOUIsTUFBTSxFQUFFO29CQUNOLFFBQVEsRUFBRSxZQUFZLENBQUMsRUFBRSxJQUFJLG9CQUFvQjtvQkFDakQsSUFBSSxFQUFFLFlBQVksQ0FBQyxJQUFJLElBQUksV0FBVztvQkFDdEMsSUFBSSxFQUFFLFlBQVksQ0FBQyxJQUFJLElBQUksR0FBRztvQkFDOUIsTUFBTSxFQUFFLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxJQUFJLEVBQUUsQ0FBQztpQkFDdkM7YUFDRixDQUFDO1NBQ0gsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/hue/hue.classes.integration.d.ts

@@ -3,9 +3,10 @@ import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/t
 import { HueConfigFlow } from './hue.classes.configflow.js';
 import type { IHueConfig } from './hue.types.js';
 export declare class HueIntegration extends BaseIntegration<IHueConfig> {
+    #private;
     readonly domain = "hue";
     readonly displayName = "Philips Hue";
-    readonly status: "control-runtime";
+    readonly status: 'control-runtime';
     readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: HueConfigFlow;
     setup(configArg: IHueConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;

package/dist_ts/integrations/hue/hue.classes.integration.js

@@ -3,55 +3,115 @@ import { HueClient } from './hue.classes.client.js';
 import { HueConfigFlow } from './hue.classes.configflow.js';
 import { createHueDiscoveryDescriptor } from './hue.discovery.js';
 import { HueMapper } from './hue.mapper.js';
+import { hueRecord } from './hue.validation.js';
 export class HueIntegration extends BaseIntegration {
     domain = 'hue';
     displayName = 'Philips Hue';
     status = 'control-runtime';
     discoveryDescriptor = createHueDiscoveryDescriptor();
     configFlow = new HueConfigFlow();
+    #runtimes = new Set();
+    #closed = false;
     async setup(configArg, contextArg) {
-        void contextArg;
-        const client = new HueClient(configArg);
-        return new HueIntegrationRuntime(client);
+        if (this.#closed)
+            throw new Error('Hue integration is closed.');
+        const client = new HueClient(configArg, contextArg.abortSignal);
+        const runtime = new HueIntegrationRuntime(client, () => this.#runtimes.delete(runtime));
+        this.#runtimes.add(runtime);
+        try {
+            await client.getResources();
+            if (this.#closed || contextArg.abortSignal?.aborted)
+                throw new Error('Hue setup was cancelled.');
+            return runtime;
+        }
+        catch (error) {
+            await runtime.destroy();
+            throw error;
+        }
+    }
+    async destroy() {
+        this.#closed = true;
+        await Promise.all([...this.#runtimes].map((runtimeArg) => runtimeArg.destroy()));
     }
-    async destroy() { }
 }
 class HueIntegrationRuntime {
     client;
+    released;
     domain = 'hue';
-    constructor(client) {
+    constructor(client, released) {
         this.client = client;
+        this.released = released;
     }
-    async devices() {
-        return HueMapper.toDevices(await this.client.getResources());
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(abortSignalArg) {
+        return HueMapper.toDevices(await this.client.getResources(abortSignalArg));
     }
     async entities() {
         return HueMapper.toEntities(await this.client.getResources());
     }
+    async subscribe(handlerArg, abortSignalArg) {
+        return this.client.subscribeToEvents((eventArg) => handlerArg(HueMapper.toIntegrationEvent(eventArg)), (errorArg) => handlerArg({ type: 'error', integrationDomain: 'hue', data: { message: errorArg.message }, timestamp: Date.now() }), abortSignalArg);
+    }
     async callService(requestArg) {
-        if (requestArg.domain !== 'light') {
-            return { success: false, error: `Unsupported Hue service domain: ${requestArg.domain}` };
-        }
-        const entityId = requestArg.target.entityId;
-        if (!entityId) {
-            return { success: false, error: 'Hue light service calls require target.entityId.' };
+        if (requestArg.domain !== 'light' || !['turn_on', 'turn_off', 'set_percentage'].includes(requestArg.service)) {
+            return { success: false, error: 'Hue supports only light turn_on, turn_off and set_percentage.' };
         }
-        const lightId = entityId.replace(/^light\./, '');
-        if (requestArg.service === 'turn_on') {
-            await this.client.setLightState(lightId, {
-                on: true,
-                brightness: typeof requestArg.data?.brightness === 'number' ? requestArg.data.brightness : undefined,
-            });
-            return { success: true };
+        const target = hueRecord(requestArg.target);
+        if (Reflect.ownKeys(target).some((keyArg) => keyArg !== 'entityId' && keyArg !== 'deviceId')) {
+            return { success: false, error: 'Hue service target contains unsupported fields.' };
         }
-        if (requestArg.service === 'turn_off') {
-            await this.client.setLightState(lightId, { on: false });
-            return { success: true };
+        const data = requestArg.data === undefined ? {} : hueRecord(requestArg.data);
+        const allowedKey = requestArg.service === 'set_percentage' ? 'percentage' : requestArg.service === 'turn_on' ? 'brightness' : undefined;
+        if (Reflect.ownKeys(data).some((keyArg) => keyArg !== allowedKey))
+            return { success: false, error: 'Hue service data contains unsupported fields.' };
+        const state = { on: requestArg.service !== 'turn_off' };
+        if (requestArg.service === 'set_percentage' || data.brightness !== undefined) {
+            const brightness = data[requestArg.service === 'set_percentage' ? 'percentage' : 'brightness'];
+            if (typeof brightness !== 'number' || !Number.isFinite(brightness) || brightness < 0 || brightness > 100) {
+                return { success: false, error: 'Hue brightness must be between 0 and 100 percent.' };
+            }
+            state.brightness = brightness;
+            if (requestArg.service === 'set_percentage')
+                state.on = brightness > 0;
         }
-        return { success: false, error: `Unsupported Hue light service: ${requestArg.service}` };
+        const snapshot = await this.client.getResources();
+        const lightId = this.resolveLight(snapshot, target.entityId, target.deviceId);
+        if (!lightId)
+            return { success: false, error: 'Hue service requires one known, unambiguous light target.' };
+        await this.client.setLightState(lightId, state);
+        return { success: true };
+    }
+    async writeFeature(requestArg, abortSignalArg) {
+        const snapshot = await this.client.getResources(abortSignalArg);
+        const device = HueMapper.toDevices(snapshot).find((deviceArg) => deviceArg.id === requestArg.device.id);
+        const feature = device?.features.find((featureArg) => featureArg.id === requestArg.feature.id && featureArg.writable);
+        const lightId = this.resolveLight(snapshot, undefined, device?.id);
+        if (!device || !device.online || !feature || !lightId)
+            return { success: false, error: 'Hue feature target is unknown, unavailable or not writable.' };
+        let state;
+        if (feature.id === 'on' && typeof requestArg.value === 'boolean')
+            state = { on: requestArg.value };
+        else if (feature.id === 'brightness' && typeof requestArg.value === 'number')
+            state = { brightness: requestArg.value };
+        else
+            return { success: false, error: 'Hue feature value has an invalid type.' };
+        await this.client.setLightState(lightId, state, abortSignalArg);
+        return { success: true };
     }
     async destroy() {
         await this.client.destroy();
+        this.released();
+    }
+    resolveLight(snapshotArg, entityIdArg, deviceIdArg) {
+        if (entityIdArg === undefined && deviceIdArg === undefined)
+            return undefined;
+        const entity = entityIdArg === undefined ? undefined : HueMapper.toEntities(snapshotArg).find((entityArg) => entityArg.id === entityIdArg);
+        const device = deviceIdArg === undefined ? undefined : snapshotArg.lights.find((lightArg) => `hue.light.${lightArg.id}` === deviceIdArg);
+        if (entityIdArg !== undefined && !entity || deviceIdArg !== undefined && !device)
+            return undefined;
+        if (entity && device && entity.deviceId !== `hue.light.${device.id}`)
+            return undefined;
+        return device?.id || (entity ? snapshotArg.lights.find((lightArg) => entity.deviceId === `hue.light.${lightArg.id}`)?.id : undefined);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hue.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/hue/hue.classes.integration.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/hue/hue.discovery.d.ts

@@ -3,13 +3,13 @@ import type { IDiscoveryCandidate, IDiscoveryContext, IDiscoveryMatch, IDiscover
 import type { IHueMdnsRecord } from './hue.types.js';
 export declare class HueBrokerDiscoveryProbe implements IDiscoveryProbe {
     id: string;
-    source: "broker";
+    source: 'broker';
     description: string;
     probe(contextArg: IDiscoveryContext): Promise<IDiscoveryProbeResult>;
 }
 export declare class HueMdnsMatcher implements IDiscoveryMatcher<IHueMdnsRecord> {
     id: string;
-    source: "mdns";
+    source: 'mdns';
     description: string;
     matches(recordArg: IHueMdnsRecord): Promise<IDiscoveryMatch>;
 }