@smarthome.exchange/integrations 0.1.0 → 1.0.0

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

@@ -1,3 +1,4 @@
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
 import { ShellyClient } from './shelly.classes.client.js';
 import { ShellyConfigFlow } from './shelly.classes.configflow.js';
@@ -17,51 +18,143 @@ export class ShellyIntegration extends BaseIntegration {
         iotClass: 'local_push',
         qualityScale: 'platinum',
     };
+    runtimes = new Set();
+    pendingClients = new Set();
+    destroyed = false;
     async setup(configArg, contextArg) {
-        void contextArg;
-        return new ShellyRuntime(new ShellyClient(configArg));
+        if (this.destroyed)
+            throw new Error('Shelly integration has been destroyed.');
+        const client = new ShellyClient(configArg, contextArg.abortSignal, contextArg.logger);
+        this.pendingClients.add(client);
+        try {
+            const snapshot = await client.getSnapshot();
+            if (this.destroyed)
+                throw new Error('Shelly integration has been destroyed.');
+            const runtime = new ShellyRuntime(client, snapshot, () => this.runtimes.delete(runtime));
+            this.runtimes.add(runtime);
+            this.pendingClients.delete(client);
+            return runtime;
+        }
+        catch (errorArg) {
+            try {
+                await client.destroy();
+            }
+            catch (cleanupErrorArg) {
+                throw new AggregateError([errorArg, cleanupErrorArg], 'Shelly setup and cleanup failed.');
+            }
+            this.pendingClients.delete(client);
+            throw errorArg;
+        }
+    }
+    async destroy() {
+        this.destroyed = true;
+        const results = await Promise.allSettled([
+            ...[...this.runtimes].map((runtimeArg) => runtimeArg.destroy()),
+            ...[...this.pendingClients].map(async (clientArg) => {
+                await clientArg.destroy();
+                this.pendingClients.delete(clientArg);
+            }),
+        ]);
+        const errors = results.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
+        if (errors.length)
+            throw new AggregateError(errors, 'Shelly integration cleanup failed.');
     }
-    async destroy() { }
 }
 export class HomeAssistantShellyIntegration extends ShellyIntegration {
 }
 class ShellyRuntime {
     client;
+    snapshot;
+    onDestroyed;
     domain = 'shelly';
-    constructor(client) {
+    constructor(client, snapshot, onDestroyed) {
         this.client = client;
+        this.snapshot = snapshot;
+        this.onDestroyed = onDestroyed;
     }
-    async devices() {
-        return ShellyMapper.toDevices(await this.client.getSnapshot());
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(abortSignalArg) {
+        this.snapshot = await this.client.getSnapshot(abortSignalArg);
+        return ShellyMapper.toDevices(this.snapshot).map((deviceArg) => ({
+            ...deviceArg,
+            online: this.isHealthy(),
+            state: deviceArg.state.map((stateArg) => stateArg.featureId === 'connectivity' ?
+                { ...stateArg, value: this.isHealthy() ? 'online' : 'offline' } : stateArg),
+        }));
     }
     async entities() {
-        return ShellyMapper.toEntities(await this.client.getSnapshot());
+        this.snapshot = await this.client.getSnapshot();
+        return ShellyMapper.toEntities(this.snapshot).map((entityArg) => ({ ...entityArg, available: this.isHealthy() }));
+    }
+    async subscribe(handlerArg, abortSignalArg) {
+        let previousEntities = ShellyMapper.toEntities(this.snapshot);
+        return this.client.subscribe((eventArg) => {
+            const deviceId = ShellyMapper.toDevices(this.snapshot)[0].id;
+            const emit = (event) => handlerArg({ ...event, integrationDomain: this.domain, deviceId, timestamp: eventArg.timestamp });
+            if (eventArg.type === 'status') {
+                this.snapshot = eventArg.snapshot;
+                const entities = ShellyMapper.toEntities(this.snapshot);
+                for (const entity of entities) {
+                    const previous = previousEntities.find((candidateArg) => candidateArg.id === entity.id);
+                    if (JSON.stringify(previous) !== JSON.stringify(entity))
+                        emit({ type: previous ? 'state_changed' : 'entity_added', entityId: entity.id, data: { entity } });
+                }
+                for (const previous of previousEntities) {
+                    if (!entities.some((entityArg) => entityArg.id === previous.id))
+                        emit({ type: 'entity_removed', entityId: previous.id });
+                }
+                previousEntities = entities;
+            }
+            else if (eventArg.type === 'availability') {
+                emit({ type: 'availability_changed', data: { available: eventArg.available } });
+            }
+            else if (eventArg.type === 'error') {
+                emit({ type: 'error', data: { message: eventArg.error.message } });
+            }
+            else {
+                emit({ type: 'state_changed', data: { vendor: 'shelly', event: eventArg.event } });
+            }
+        }, abortSignalArg);
     }
     async callService(requestArg) {
-        if (requestArg.domain !== 'switch') {
-            return { success: false, error: `Unsupported Shelly service domain: ${requestArg.domain}` };
-        }
-        const switchId = this.resolveSwitchId(requestArg.target.entityId, requestArg.target.deviceId);
-        if (switchId === undefined) {
-            return { success: false, error: 'Shelly switch service calls require a switch entity or device target with a numeric switch id.' };
-        }
-        if (requestArg.service === 'turn_on') {
-            await this.client.setSwitchOutput(switchId, true);
-            return { success: true };
-        }
-        if (requestArg.service === 'turn_off') {
-            await this.client.setSwitchOutput(switchId, false);
-            return { success: true };
-        }
-        return { success: false, error: `Unsupported Shelly switch service: ${requestArg.service}` };
+        if (requestArg.domain !== 'switch' || !['turn_on', 'turn_off'].includes(requestArg.service))
+            return { success: false, error: 'Shelly supports switch.turn_on and switch.turn_off.' };
+        if (requestArg.data && Object.keys(requestArg.data).length)
+            return { success: false, error: 'Shelly switch services do not accept additional data.' };
+        this.snapshot = await this.client.getSnapshot();
+        const deviceId = ShellyMapper.toDevices(this.snapshot)[0].id;
+        if (requestArg.target.deviceId !== undefined && requestArg.target.deviceId !== deviceId)
+            return { success: false, error: 'Shelly service target does not belong to the connected device.' };
+        const switches = ShellyMapper.toEntities(this.snapshot).filter((entityArg) => entityArg.platform === 'switch');
+        const target = requestArg.target.entityId !== undefined ? switches.find((entityArg) => entityArg.id === requestArg.target.entityId) :
+            requestArg.target.deviceId === deviceId && switches.length === 1 ? switches[0] : undefined;
+        if (!target)
+            return { success: false, error: 'Shelly service requires an exact switch entity or an unambiguous device target.' };
+        const switchId = this.componentId(target.uniqueId);
+        if (switchId === undefined)
+            return { success: false, error: 'Shelly switch target has no component id.' };
+        await this.client.setSwitchOutput(switchId, requestArg.service === 'turn_on');
+        return { success: true };
+    }
+    async writeFeature(requestArg, abortSignalArg) {
+        this.snapshot = await this.client.getSnapshot(abortSignalArg);
+        const device = ShellyMapper.toDevices(this.snapshot)[0];
+        if (requestArg.device.id !== device.id || requestArg.device.integrationDomain !== this.domain)
+            return { success: false, error: 'Shelly feature target does not belong to the connected device.' };
+        const feature = device.features.find((featureArg) => featureArg.id === requestArg.feature.id);
+        const match = feature && /^switch_(\d+)_output$/.exec(feature.id);
+        if (!match || !feature.writable || feature.capability !== 'switch' || typeof requestArg.value !== 'boolean')
+            return { success: false, error: 'Shelly writes require a writable switch output and boolean value.' };
+        await this.client.setSwitchOutput(Number(match[1]), requestArg.value, abortSignalArg);
+        return { success: true };
     }
     async destroy() {
         await this.client.destroy();
+        this.onDestroyed();
     }
-    resolveSwitchId(entityIdArg, deviceIdArg) {
-        const candidate = entityIdArg || deviceIdArg;
-        const match = candidate?.match(/(?:switch[_\.]|_)(\d+)$/);
+    componentId(uniqueIdArg) {
+        const match = /_switch_(\d+)$/.exec(uniqueIdArg);
         return match ? Number(match[1]) : undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shelly.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/shelly/shelly.classes.integration.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/shelly/shelly.classes.subscription.d.ts

@@ -0,0 +1,47 @@
+import type { IShellyComponentEvent, IShellyStatus } from './shelly.types.js';
+interface IShellySubscriptionOptions {
+    url: string;
+    deviceId: string;
+    source: string;
+    password?: string;
+    timeoutMs: number;
+    abortSignal: AbortSignal;
+    onStatus(statusArg: IShellyStatus, fullArg: boolean, timestampArg: number): void;
+    onEvent(eventArg: IShellyComponentEvent, timestampArg: number): void;
+    onAvailability(availableArg: boolean): void;
+    onError(errorArg: Error): void;
+}
+export declare class ShellySubscription {
+    private readonly options;
+    private socket?;
+    private startPromise?;
+    private resolveStart?;
+    private rejectStart?;
+    private closePromise?;
+    private resolveClose?;
+    private deadline?;
+    private requestId;
+    private authAttempted;
+    private healthy;
+    private closed;
+    private stopping;
+    constructor(options: IShellySubscriptionOptions);
+    get isHealthy(): boolean;
+    get isClosed(): boolean;
+    get isStopping(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private readonly handleOpen;
+    private readonly handleMessage;
+    private authenticate;
+    private sendHandshake;
+    private receiveNotification;
+    private readonly handleError;
+    private readonly handleClose;
+    private readonly handleAbort;
+    private fail;
+    private setHealthy;
+    private clearDeadline;
+    private finishClose;
+}
+export {};

package/dist_ts/integrations/shelly/shelly.classes.subscription.js

@@ -0,0 +1,206 @@
+import { AuthenticationError, DeviceCommunicationError } from '../../core/errors.js';
+import { createShellyDigest, isShellyRecord, parseShellyDigestChallenge, parseShellyEvents, parseShellyRpcResult, parseShellyStatus, } from './shelly.rpc.js';
+export class ShellySubscription {
+    options;
+    socket;
+    startPromise;
+    resolveStart;
+    rejectStart;
+    closePromise;
+    resolveClose;
+    deadline;
+    requestId = 1;
+    authAttempted = false;
+    healthy = false;
+    closed = false;
+    stopping = false;
+    constructor(options) {
+        this.options = options;
+    }
+    get isHealthy() { return this.healthy && !this.stopping; }
+    get isClosed() { return this.closed; }
+    get isStopping() { return this.stopping; }
+    start() {
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.options.abortSignal.aborted || this.stopping)
+            return Promise.reject(new DOMException('Shelly subscription cancelled.', 'AbortError'));
+        this.startPromise = new Promise((resolveArg, rejectArg) => {
+            this.resolveStart = resolveArg;
+            this.rejectStart = rejectArg;
+        });
+        this.closePromise = new Promise((resolveArg) => { this.resolveClose = resolveArg; });
+        this.options.abortSignal.addEventListener('abort', this.handleAbort, { once: true });
+        this.deadline = setTimeout(() => this.fail(new DeviceCommunicationError('Shelly WebSocket handshake timed out.')), this.options.timeoutMs);
+        try {
+            this.socket = new WebSocket(this.options.url);
+            this.socket.addEventListener('open', this.handleOpen);
+            this.socket.addEventListener('message', this.handleMessage);
+            this.socket.addEventListener('error', this.handleError);
+            this.socket.addEventListener('close', this.handleClose);
+        }
+        catch {
+            this.finishClose();
+            this.fail(new DeviceCommunicationError('Shelly WebSocket connection failed.'));
+        }
+        return this.startPromise;
+    }
+    async stop() {
+        this.stopping = true;
+        this.setHealthy(false);
+        this.clearDeadline();
+        this.rejectStart?.(new DOMException('Shelly subscription cancelled.', 'AbortError'));
+        this.resolveStart = undefined;
+        this.rejectStart = undefined;
+        if (!this.socket || this.closed) {
+            this.finishClose();
+            return;
+        }
+        if (this.socket.readyState < WebSocket.CLOSING)
+            this.socket.close();
+        let timer;
+        try {
+            // Native WebSocket owns its transport; a failed close remains owned and can be awaited again.
+            await Promise.race([
+                this.closePromise,
+                new Promise((_, rejectArg) => {
+                    timer = setTimeout(() => rejectArg(new DeviceCommunicationError('Shelly WebSocket close timed out.')), this.options.timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    handleOpen = () => {
+        if (!this.stopping)
+            this.sendHandshake();
+    };
+    handleMessage = (eventArg) => {
+        if (this.stopping)
+            return;
+        try {
+            if (typeof eventArg.data !== 'string' || eventArg.data.length > 1024 * 1024) {
+                throw new DeviceCommunicationError('Shelly returned an invalid WebSocket frame.');
+            }
+            const frame = JSON.parse(eventArg.data);
+            if (!isShellyRecord(frame) || frame.src !== this.options.deviceId || frame.dst !== this.options.source) {
+                throw new DeviceCommunicationError('Shelly WebSocket frame identity does not match the connected device.');
+            }
+            if (typeof frame.method === 'string') {
+                if (this.healthy)
+                    this.receiveNotification(frame);
+                return;
+            }
+            if (frame.id !== this.requestId || this.healthy) {
+                throw new DeviceCommunicationError('Shelly returned an unexpected WebSocket response.');
+            }
+            if (isShellyRecord(frame.error) && frame.error.code === 401 && !this.authAttempted) {
+                this.authenticate(frame.error);
+                return;
+            }
+            const status = parseShellyStatus(parseShellyRpcResult(frame, this.requestId, this.options.deviceId, this.options.source));
+            this.options.onStatus(status, true, Date.now());
+            this.clearDeadline();
+            this.setHealthy(true);
+            this.resolveStart?.();
+            this.resolveStart = undefined;
+            this.rejectStart = undefined;
+        }
+        catch (errorArg) {
+            this.fail(errorArg instanceof AuthenticationError || errorArg instanceof DeviceCommunicationError ?
+                errorArg : new DeviceCommunicationError('Shelly returned an invalid WebSocket payload.'));
+        }
+    };
+    authenticate(errorArg) {
+        if (!this.options.password)
+            throw new AuthenticationError('Shelly authentication requires a password.');
+        if (typeof errorArg.message !== 'string')
+            throw new AuthenticationError('Shelly returned an unsupported authentication challenge.');
+        let challengeValue;
+        try {
+            challengeValue = JSON.parse(errorArg.message);
+        }
+        catch {
+            throw new AuthenticationError('Shelly returned an unsupported authentication challenge.');
+        }
+        const challenge = parseShellyDigestChallenge(challengeValue, this.options.deviceId);
+        const digest = createShellyDigest(challenge, this.options.password, challenge.nc ?? 1, 'dummy_method', 'dummy_uri');
+        this.authAttempted = true;
+        this.requestId++;
+        this.sendHandshake({
+            realm: challenge.realm,
+            username: 'admin',
+            nonce: challenge.nonce,
+            algorithm: 'SHA-256',
+            ...digest,
+        });
+    }
+    sendHandshake(authArg) {
+        this.socket?.send(JSON.stringify({ id: this.requestId, src: this.options.source, method: 'Shelly.GetStatus', auth: authArg }));
+    }
+    receiveNotification(frameArg) {
+        if (!['NotifyStatus', 'NotifyFullStatus', 'NotifyEvent'].includes(String(frameArg.method)))
+            return;
+        if (!isShellyRecord(frameArg.params) || typeof frameArg.params.ts !== 'number' ||
+            !Number.isSafeInteger(Math.trunc(frameArg.params.ts * 1000)) || frameArg.params.ts < 0) {
+            throw new DeviceCommunicationError('Shelly returned an invalid notification.');
+        }
+        const { ts, ...params } = frameArg.params;
+        const timestamp = ts * 1000;
+        if (frameArg.method === 'NotifyEvent') {
+            for (const event of parseShellyEvents(params.events))
+                this.options.onEvent(event, (event.ts ?? ts) * 1000);
+        }
+        else {
+            const full = frameArg.method === 'NotifyFullStatus';
+            this.options.onStatus(parseShellyStatus(params, !full), full, timestamp);
+        }
+    }
+    handleError = () => {
+        if (!this.stopping)
+            this.fail(new DeviceCommunicationError('Shelly WebSocket connection failed.'));
+    };
+    handleClose = () => {
+        const unexpected = !this.stopping;
+        this.finishClose();
+        if (unexpected)
+            this.fail(new DeviceCommunicationError('Shelly WebSocket connection closed.'));
+    };
+    handleAbort = () => {
+        void this.stop().catch(() => this.options.onError(new DeviceCommunicationError('Shelly WebSocket cleanup failed.')));
+    };
+    fail(errorArg) {
+        this.setHealthy(false);
+        this.clearDeadline();
+        this.rejectStart?.(errorArg);
+        this.resolveStart = undefined;
+        this.rejectStart = undefined;
+        this.options.onError(errorArg);
+        if (!this.stopping)
+            void this.stop().catch(() => this.options.onError(new DeviceCommunicationError('Shelly WebSocket cleanup failed.')));
+    }
+    setHealthy(healthyArg) {
+        if (this.healthy === healthyArg)
+            return;
+        this.healthy = healthyArg;
+        this.options.onAvailability(healthyArg);
+    }
+    clearDeadline() {
+        clearTimeout(this.deadline);
+        this.deadline = undefined;
+    }
+    finishClose() {
+        this.closed = true;
+        this.clearDeadline();
+        this.setHealthy(false);
+        this.options.abortSignal.removeEventListener('abort', this.handleAbort);
+        this.socket?.removeEventListener('open', this.handleOpen);
+        this.socket?.removeEventListener('message', this.handleMessage);
+        this.socket?.removeEventListener('error', this.handleError);
+        this.socket?.removeEventListener('close', this.handleClose);
+        this.resolveClose?.();
+        this.resolveClose = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shelly.classes.subscription.js","sourceRoot":"","sources":["../../../ts/integrations/shelly/shelly.classes.subscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAgBzB,MAAM,OAAO,kBAAkB;IAcA,OAAO;IAb5B,MAAM,CAAa;IACnB,YAAY,CAAiB;IAC7B,YAAY,CAAc;IAC1B,WAAW,CAA6B;IACxC,YAAY,CAAiB;IAC7B,YAAY,CAAc;IAC1B,QAAQ,CAAiC;IACzC,SAAS,GAAG,CAAC,CAAC;IACd,aAAa,GAAG,KAAK,CAAC;IACtB,OAAO,GAAG,KAAK,CAAC;IAChB,MAAM,GAAG,KAAK,CAAC;IACf,QAAQ,GAAG,KAAK,CAAC;IAEzB,YAA6B,OAAmC;uBAAnC,OAAO;IAA+B,CAAC;IAEpE,IAAW,SAAS,KAAc,OAAO,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1E,IAAW,QAAQ,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACtD,IAAW,UAAU,KAAc,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEnD,KAAK;QACV,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC;QAChD,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAC,CAAC;QAC/I,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,CAAO,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE;YAC9D,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC;YAC/B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC/B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,CAAO,CAAC,UAAU,EAAE,EAAE,GAAG,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3F,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACrF,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,wBAAwB,CAAC,uCAAuC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC3I,IAAI,CAAC;YACH,IAAI,CAAC,MAAM,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC9C,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YACtD,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;YAC5D,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACxD,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1D,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,IAAI,CAAC,IAAI,wBAAwB,CAAC,qCAAqC,CAAC,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,YAAY,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAC,CAAC;QACrF,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC,OAAO;YAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,KAAgD,CAAC;QACrD,IAAI,CAAC;YACH,8FAA8F;YAC9F,MAAM,OAAO,CAAC,IAAI,CAAC;gBACjB,IAAI,CAAC,YAAY;gBACjB,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE;oBAClC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,wBAAwB,CAAC,mCAAmC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBACjI,CAAC,CAAC;aACH,CAAC,CAAC;QACL,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAEgB,UAAU,GAAG,GAAS,EAAE;QACvC,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,aAAa,EAAE,CAAC;IAC3C,CAAC,CAAC;IAEe,aAAa,GAAG,CAAC,QAA+B,EAAQ,EAAE;QACzE,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC;YACH,IAAI,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC;gBAC5E,MAAM,IAAI,wBAAwB,CAAC,6CAA6C,CAAC,CAAC;YACpF,CAAC;YACD,MAAM,KAAK,GAAY,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACjD,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBACvG,MAAM,IAAI,wBAAwB,CAAC,sEAAsE,CAAC,CAAC;YAC7G,CAAC;YACD,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACrC,IAAI,IAAI,CAAC,OAAO;oBAAE,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;gBAClD,OAAO;YACT,CAAC;YACD,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAChD,MAAM,IAAI,wBAAwB,CAAC,mDAAmD,CAAC,CAAC;YAC1F,CAAC;YACD,IAAI,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnF,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC/B,OAAO;YACT,CAAC;YACD,MAAM,MAAM,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;YAC1H,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;YAChD,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC/B,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,IAAI,CAAC,QAAQ,YAAY,mBAAmB,IAAI,QAAQ,YAAY,wBAAwB,CAAC,CAAC;gBACjG,QAAQ,CAAC,CAAC,CAAC,IAAI,wBAAwB,CAAC,+CAA+C,CAAC,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC,CAAC;IAEM,YAAY,CAAC,QAAiC;QACpD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ;YAAE,MAAM,IAAI,mBAAmB,CAAC,4CAA4C,CAAC,CAAC;QACxG,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,QAAQ;YAAE,MAAM,IAAI,mBAAmB,CAAC,0DAA0D,CAAC,CAAC;QACpI,IAAI,cAAuB,CAAC;QAC5B,IAAI,CAAC;YAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAAC,CAAC;QACtD,MAAM,CAAC;YAAC,MAAM,IAAI,mBAAmB,CAAC,0DAA0D,CAAC,CAAC;QAAC,CAAC;QACpG,MAAM,SAAS,GAAG,0BAA0B,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpF,MAAM,MAAM,GAAG,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;QACpH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,aAAa,CAAC;YACjB,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,QAAQ,EAAE,OAAO;YACjB,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,SAAS,EAAE,SAAS;YACpB,GAAG,MAAM;SACV,CAAC,CAAC;IACL,CAAC;IAEO,aAAa,CAAC,OAAiC;QACrD,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACjI,CAAC;IAEO,mBAAmB,CAAC,QAAiC;QAC3D,IAAI,CAAC,CAAC,cAAc,EAAE,kBAAkB,EAAE,aAAa,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAAE,OAAO;QACnG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ;YAC5E,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACzF,MAAM,IAAI,wBAAwB,CAAC,0CAA0C,CAAC,CAAC;QACjF,CAAC;QACD,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC1C,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC;QAC5B,IAAI,QAAQ,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;YACtC,KAAK,MAAM,KAAK,IAAI,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC;gBAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7G,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,KAAK,kBAAkB,CAAC;YACpD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IAEgB,WAAW,GAAG,GAAS,EAAE;QACxC,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,wBAAwB,CAAC,qCAAqC,CAAC,CAAC,CAAC;IACrG,CAAC,CAAC;IAEe,WAAW,GAAG,GAAS,EAAE;QACxC,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;QAClC,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,UAAU;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,wBAAwB,CAAC,qCAAqC,CAAC,CAAC,CAAC;IACjG,CAAC,CAAC;IAEe,WAAW,GAAG,GAAS,EAAE;QACxC,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,wBAAwB,CAAC,kCAAkC,CAAC,CAAC,CAAC,CAAC;IACvH,CAAC,CAAC;IAEM,IAAI,CAAC,QAAe;QAC1B,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC7B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,wBAAwB,CAAC,kCAAkC,CAAC,CAAC,CAAC,CAAC;IAC3I,CAAC;IAEO,UAAU,CAAC,UAAmB;QACpC,IAAI,IAAI,CAAC,OAAO,KAAK,UAAU;YAAE,OAAO;QACxC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC1C,CAAC;IAEO,aAAa;QACnB,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;IAC5B,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QACxE,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC1D,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;IAChC,CAAC;CACF"}

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

@@ -3,13 +3,13 @@ import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscover
 import type { IShellyManualEntry, IShellyMdnsRecord } from './shelly.types.js';
 export declare class ShellyMdnsMatcher implements IDiscoveryMatcher<IShellyMdnsRecord> {
     id: string;
-    source: "mdns";
+    source: 'mdns';
     description: string;
     matches(recordArg: IShellyMdnsRecord): Promise<IDiscoveryMatch>;
 }
 export declare class ShellyManualMatcher implements IDiscoveryMatcher<IShellyManualEntry> {
     id: string;
-    source: "manual";
+    source: 'manual';
     description: string;
     matches(inputArg: IShellyManualEntry): Promise<IDiscoveryMatch>;
 }

package/dist_ts/integrations/shelly/shelly.discovery.js

@@ -5,8 +5,10 @@ export class ShellyMdnsMatcher {
     description = 'Recognize Shelly zeroconf records advertised as shelly* or _shelly._tcp.local.';
     async matches(recordArg) {
         const name = recordArg.name?.toLowerCase() || '';
-        const type = recordArg.type?.toLowerCase() || '';
-        const matched = name.startsWith('shelly') || type === '_shelly._tcp.local.' || type === '_http._tcp.local.' && name.startsWith('shelly');
+        const type = recordArg.type?.toLowerCase().replace(/\.$/, '').replace(/\.local$/, '') || '';
+        const generation = recordArg.txt?.gen;
+        const supportedGeneration = generation === undefined || generation === '2' || generation === '3';
+        const matched = supportedGeneration && (type === '_shelly._tcp' || type === '_http._tcp' && name.startsWith('shelly'));
         if (!matched) {
             return {
                 matched: false,
@@ -32,6 +34,7 @@ export class ShellyMdnsMatcher {
                     mdnsName: recordArg.name,
                     mdnsType: recordArg.type,
                     txt: recordArg.txt,
+                    generation,
                 },
             },
         };
@@ -97,4 +100,4 @@ export const createShellyDiscoveryDescriptor = () => {
         .addMatcher(new ShellyManualMatcher())
         .addValidator(new ShellyCandidateValidator());
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/shelly/shelly.rpc.d.ts

@@ -0,0 +1,21 @@
+import type { IShellyComponentEvent, IShellyDeviceConfig, IShellyDeviceInfo, IShellyStatus } from './shelly.types.js';
+export declare const isShellyRecord: (valueArg: unknown) => valueArg is Record<string, unknown>;
+export declare const parseShellyDeviceInfo: (valueArg: unknown) => IShellyDeviceInfo;
+export declare const parseShellyStatus: (valueArg: unknown, partialArg?: boolean) => IShellyStatus;
+export declare const parseShellyConfig: (valueArg: unknown) => IShellyDeviceConfig;
+export declare const parseShellyEvents: (valueArg: unknown) => IShellyComponentEvent[];
+export declare const mergeShellyStatus: (statusArg: IShellyStatus, patchArg: IShellyStatus) => IShellyStatus;
+export interface IShellyDigestChallenge {
+    realm: string;
+    nonce: string | number;
+    nc?: number;
+    opaque?: string;
+}
+export declare const parseShellyDigestChallenge: (valueArg: unknown, deviceIdArg?: string) => IShellyDigestChallenge;
+export declare const parseShellyHttpChallenge: (headerArg: string | null, deviceIdArg?: string) => IShellyDigestChallenge;
+export declare const createShellyDigest: (challengeArg: IShellyDigestChallenge, passwordArg: string, countArg: number, methodArg: string, uriArg: string) => {
+    response: string;
+    cnonce: number;
+    nc: string | number;
+};
+export declare const parseShellyRpcResult: (frameArg: unknown, idArg: number, deviceIdArg?: string, sourceArg?: string) => Record<string, unknown>;