@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -1,99 +1,207 @@
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 import { DaikinClient } from './daikin.classes.client.js';
 import { DaikinConfigFlow } from './daikin.classes.configflow.js';
 import { createDaikinDiscoveryDescriptor } from './daikin.discovery.js';
 import { DaikinMapper } from './daikin.mapper.js';
-import { daikinDisplayName, daikinDomain } from './daikin.types.js';
+import { normalizeDaikinConfig } from './daikin.validation.js';
+const failure = (errorArg) => ({
+    success: false, error: errorArg instanceof Error ? errorArg.message : 'Daikin operation failed.',
+    data: errorArg instanceof plugins.ecobridgeDeviceManager.DaikinProtocolError
+        ? { code: errorArg.code, effectOutcome: errorArg.effectOutcome }
+        : { effectOutcome: 'not-sent' },
+});
 export class DaikinIntegration extends BaseIntegration {
-    domain = daikinDomain;
-    displayName = daikinDisplayName;
+    domain = 'daikin';
+    displayName = 'Daikin BRP069';
     status = 'control-runtime';
     discoveryDescriptor = createDaikinDiscoveryDescriptor();
-    configFlow = new DaikinConfigFlow();
+    configFlow;
     metadata = {
-        source: 'home-assistant/core',
-        upstreamPath: 'homeassistant/components/daikin',
-        upstreamDomain: daikinDomain,
-        integrationType: 'device',
-        iotClass: 'local_polling',
-        requirements: ['pydaikin==2.17.2'],
-        dependencies: [],
-        afterDependencies: [],
-        codeowners: ['@fredrike'],
-        configFlow: true,
-        documentation: 'https://www.home-assistant.io/integrations/daikin',
-        zeroconf: ['_dkapi._tcp.local.'],
-        discovery: {
-            zeroconf: '_dkapi._tcp.local.',
-            udp: 'DAIKIN_UDP/common/basic_info broadcast on UDP 30050 from source port 30000.',
-            http: 'Manual HTTP candidates for /common/basic_info, /aircon/*, /skyfi/*, and /dsiot/* are recognized.',
-            manual: true,
-        },
-        runtime: {
-            type: 'control-runtime',
-            polling: 'local Daikin HTTP key/value APIs plus SkyFi and BRP084 dsiot read modeling',
-            services: ['snapshot', 'status', 'refresh', 'climate controls', 'power switch', 'zone switch', 'streamer', 'holiday/advanced modes when represented by local endpoints'],
-            controls: true,
-        },
+        source: '@ecobridge.xyz/devicemanager', upstreamDomain: 'daikin', integrationType: 'device', iotClass: 'local_polling',
         localApi: {
-            implemented: [
-                'BRP069-style key/value local HTTP reads and set_control_info writes',
-                'BRP072C register_terminal/API-key request modeling when HTTPS is usable by the runtime',
-                'AirBase skyfi-prefixed reads plus zone setting writes',
-                'SkyFi password API reads and set.cgi/setzone.cgi writes',
-                'BRP084 dsiot snapshot reads',
-                'snapshot/manual-data and injected client/executor operation',
-            ],
-            explicitUnsupported: [
-                'BRP084 dsiot control writes without an injected commandExecutor',
-                'faking command success for snapshot/manual-only configurations',
-                'forcing TLS certificate bypass for BRP072C self-signed devices through Node fetch',
-            ],
+            implemented: ['selected BRP069 fresh identity/model/control observations', 'explicit power', 'integer target in observed cool or heat mode', 'independent readback'],
+            explicitUnsupported: ['automatic family selection', 'mode/humidity/fan/direction changes', 'other controller-family effects', 'cloud', 'retries', 'optimistic state', 'injected effect executors'],
         },
     };
+    #owner;
+    constructor(optionsArg = {}) {
+        super();
+        this.#owner = new NativeIntegrationOwner(this.domain, optionsArg);
+        this.configFlow = new DaikinConfigFlow({}, this.#owner.createFlowScope());
+    }
     async setup(configArg, contextArg) {
-        void contextArg;
-        return new DaikinRuntime(new DaikinClient(configArg));
+        const config = normalizeDaikinConfig(configArg);
+        return this.#owner.runSetup(contextArg, config.homeId, async (leaseArg) => {
+            const client = new DaikinClient(config, leaseArg.context);
+            let runtime;
+            leaseArg.own(() => runtime ? runtime.cleanupOwnedResource() : client.destroy());
+            const identity = await client.getSnapshot(leaseArg.signal);
+            leaseArg.assertOpen();
+            runtime = new DaikinRuntime(client, identity, leaseArg, leaseArg.context.logger);
+            leaseArg.promoteToRuntime();
+            return runtime;
+        });
     }
-    async destroy() { }
+    destroy() { return this.#owner.close(); }
+    retryCleanup() { return this.#owner.retryCleanup(); }
 }
 export class HomeAssistantDaikinIntegration extends DaikinIntegration {
 }
 class DaikinRuntime {
     client;
-    domain = daikinDomain;
-    constructor(client) {
+    lease;
+    logger;
+    domain = 'daikin';
+    #identity;
+    #subscriptions = new Set();
+    #entities;
+    #available = true;
+    #destroy;
+    #removeAbort = () => undefined;
+    constructor(client, identityArg, lease, logger) {
         this.client = client;
+        this.lease = lease;
+        this.logger = logger;
+        this.#identity = structuredClone(identityArg);
+        this.#entities = DaikinMapper.toEntities(identityArg);
+        // The lease retains failed cleanup; destroy() and the owner expose its stable rejection.
+        const aborted = () => { void this.destroy().catch(() => undefined); };
+        lease.signal.addEventListener('abort', aborted, { once: true });
+        this.#removeAbort = () => lease.signal.removeEventListener('abort', aborted);
+        if (lease.signal.aborted)
+            aborted();
     }
-    async devices() {
-        return DaikinMapper.toDevices(await this.client.getSnapshot());
+    isHealthy() { return !this.#destroy && this.client.isHealthy(); }
+    async devices(signalArg) {
+        return DaikinMapper.toDevices(await this.#snapshot(signalArg));
     }
-    async entities() {
-        return DaikinMapper.toEntities(await this.client.getSnapshot());
+    async entities() { return DaikinMapper.toEntities(await this.#snapshot()); }
+    async subscribe(handlerArg, signalArg) {
+        this.#assertOpen();
+        if (typeof handlerArg !== 'function')
+            throw new TypeError('Daikin subscriber must be a function.');
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            throw new TypeError('Daikin subscriber signal must be an AbortSignal.');
+        signalArg?.throwIfAborted();
+        if (this.#subscriptions.size >= 128)
+            throw new Error('Daikin subscriber capacity is exhausted.');
+        const subscriber = { handler: handlerArg, cleanup: () => {
+                this.#subscriptions.delete(subscriber);
+                signalArg?.removeEventListener('abort', subscriber.cleanup);
+            } };
+        this.#subscriptions.add(subscriber);
+        signalArg?.addEventListener('abort', subscriber.cleanup, { once: true });
+        if (signalArg?.aborted)
+            subscriber.cleanup();
+        return async () => subscriber.cleanup();
     }
     async callService(requestArg) {
         try {
-            if (requestArg.domain === daikinDomain && (requestArg.service === 'snapshot' || requestArg.service === 'status')) {
-                return { success: true, data: await this.client.getSnapshot() };
-            }
-            if (requestArg.domain === daikinDomain && requestArg.service === 'refresh') {
-                const result = await this.client.refresh();
-                return { success: result.success, error: result.error, data: result.snapshot || result.data };
+            this.#assertOpen();
+            const control = DaikinMapper.controlForService(this.#identity, requestArg);
+            if (control === 'snapshot') {
+                const snapshot = await this.client.getSnapshot();
+                this.#observe(snapshot);
+                return { success: true, data: snapshot };
             }
-            const snapshot = await this.client.getSnapshot();
-            const command = DaikinMapper.commandForService(snapshot, requestArg);
-            if (!command) {
-                return { success: false, error: `Unsupported Daikin service: ${requestArg.domain}.${requestArg.service}` };
-            }
-            const data = await this.client.execute(command);
-            return { success: true, data: data ?? command };
+            return this.#result(await this.client.setControl(control));
+        }
+        catch (errorArg) {
+            this.#report(errorArg);
+            return failure(errorArg);
+        }
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            this.#assertOpen();
+            return this.#result(await this.client.setControl(DaikinMapper.controlForFeature(this.#identity, requestArg), signalArg));
+        }
+        catch (errorArg) {
+            this.#report(errorArg);
+            return failure(errorArg);
+        }
+    }
+    destroy() {
+        this.#destroy ??= Promise.resolve().then(() => this.lease.close());
+        return this.#destroy;
+    }
+    /** One adapter resource groups its client and subscriptions; every sibling must settle. */
+    async cleanupOwnedResource() {
+        const results = await Promise.allSettled([
+            Promise.resolve().then(() => this.#removeAbort()),
+            ...[...this.#subscriptions].map((subscriberArg) => Promise.resolve().then(() => subscriberArg.cleanup())),
+            Promise.resolve().then(() => this.client.destroy()),
+        ]);
+        const errors = results.filter((resultArg) => resultArg.status === 'rejected').map((resultArg) => resultArg.reason);
+        if (errors.length)
+            throw new AggregateError(errors, 'Daikin runtime resource cleanup failed.');
+    }
+    async #snapshot(signalArg) {
+        this.#assertOpen();
+        try {
+            const snapshot = await this.client.getSnapshot(signalArg);
+            this.#observe(snapshot);
+            return snapshot;
         }
         catch (errorArg) {
-            return { success: false, error: errorArg instanceof Error ? errorArg.message : String(errorArg) };
+            this.#report(errorArg);
+            throw errorArg;
+        }
+    }
+    #result(dataArg) {
+        this.#observe(DaikinMapper.fromState(this.client.config, dataArg.observed));
+        return { success: dataArg.effectOutcome === 'confirmed', data: dataArg,
+            error: dataArg.effectOutcome === 'confirmed' ? undefined : 'Daikin setter was accepted but requested state was not confirmed by observation.' };
+    }
+    #observe(snapshotArg) {
+        const entities = DaikinMapper.toEntities(snapshotArg);
+        if (!this.#available)
+            this.#emit({ type: 'availability_changed', data: { available: true } });
+        this.#available = true;
+        for (const entity of entities) {
+            const previous = this.#entities.find((entryArg) => entryArg.id === entity.id);
+            if (!previous || JSON.stringify([previous.state, previous.attributes]) !== JSON.stringify([entity.state, entity.attributes])) {
+                this.#emit({ type: 'state_changed', entityId: entity.id, data: entity });
+            }
         }
+        this.#entities = entities;
+    }
+    #report(errorArg) {
+        if (!this.client.isHealthy() && this.#available) {
+            this.#available = false;
+            this.#emit({ type: 'availability_changed', data: { available: false } });
+        }
+        this.#emit({ type: 'error', data: failure(errorArg) });
+    }
+    #emit(eventArg) {
+        if (this.#destroy)
+            return;
+        const event = { ...eventArg, integrationDomain: this.domain,
+            deviceId: DaikinMapper.deviceId(this.#identity), timestamp: Date.now() };
+        for (const subscriber of [...this.#subscriptions]) {
+            if (!this.#subscriptions.has(subscriber))
+                continue;
+            try {
+                const returned = subscriber.handler(structuredClone(event));
+                if (returned instanceof Promise)
+                    void returned.catch(() => this.#subscriberFailed(subscriber));
+            }
+            catch {
+                this.#subscriberFailed(subscriber);
+            }
+        }
+    }
+    #subscriberFailed(subscriberArg) {
+        subscriberArg.cleanup();
+        this.logger?.log('error', 'Daikin event subscriber failed.');
+        this.#emit({ type: 'error', data: { error: 'Daikin event subscriber failed.' } });
     }
-    async destroy() {
-        await this.client.destroy();
+    #assertOpen() {
+        if (this.#destroy)
+            throw new Error('Daikin runtime is destroyed.');
+        this.lease.assertOpen();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daikin.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/daikin/daikin.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -1,42 +1,29 @@
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
-import type { IDiscoveryCandidate, IDiscoveryContext, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryProbe, IDiscoveryProbeResult, IDiscoveryValidator } from '../../core/types.js';
+import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
 import type { IDaikinHttpCandidateRecord, IDaikinManualEntry, IDaikinMdnsRecord, IDaikinUdpDiscoveryRecord } from './daikin.types.js';
-export declare class DaikinUdpDiscoveryProbe implements IDiscoveryProbe {
-    id: string;
-    source: "custom";
-    description: string;
-    probe(contextArg: IDiscoveryContext): Promise<IDiscoveryProbeResult>;
-    private discover;
-}
 export declare class DaikinZeroconfMatcher implements IDiscoveryMatcher<IDaikinMdnsRecord> {
-    id: string;
-    source: "mdns";
-    description: string;
+    readonly id = "daikin-zeroconf-match";
+    readonly source: 'mdns';
     matches(recordArg: IDaikinMdnsRecord): Promise<IDiscoveryMatch>;
 }
 export declare class DaikinUdpMatcher implements IDiscoveryMatcher<IDaikinUdpDiscoveryRecord> {
-    id: string;
-    source: "custom";
-    description: string;
+    readonly id = "daikin-udp-match";
+    readonly source: 'custom';
     matches(recordArg: IDaikinUdpDiscoveryRecord): Promise<IDiscoveryMatch>;
-    private values;
 }
 export declare class DaikinHttpMatcher implements IDiscoveryMatcher<IDaikinHttpCandidateRecord> {
-    id: string;
-    source: "http";
-    description: string;
+    readonly id = "daikin-http-match";
+    readonly source: 'http';
     matches(recordArg: IDaikinHttpCandidateRecord): Promise<IDiscoveryMatch>;
-    private parseBody;
 }
 export declare class DaikinManualMatcher implements IDiscoveryMatcher<IDaikinManualEntry> {
-    id: string;
-    source: "manual";
-    description: string;
+    readonly id = "daikin-manual-match";
+    readonly source: 'manual';
     matches(inputArg: IDaikinManualEntry): Promise<IDiscoveryMatch>;
 }
 export declare class DaikinCandidateValidator implements IDiscoveryValidator {
-    id: string;
-    description: string;
+    readonly id = "daikin-candidate-validator";
     validate(candidateArg: IDiscoveryCandidate): Promise<IDiscoveryMatch>;
 }
+/** Passive record matching only; setup independently validates the explicitly selected controller. */
 export declare const createDaikinDiscoveryDescriptor: () => DiscoveryDescriptor;