@smarthome.exchange/integrations 1.0.0 → 2.0.0

package/dist_ts/integrations/modbus/modbus.classes.configflow.d.ts

@@ -1,7 +1,11 @@
-import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
-import type { IModbusConfig } from './modbus.types.js';
+import { type NativeIntegrationScope } from '../../core/classes.nativeintegrationowner.js';
+import type { IConfigFlow, IConfigFlowStep, IDiscoveryCandidate, INativeConfigFlowContext } from '../../core/types.js';
+import type { IModbusConfig, IModbusIntegrationOptions } from './modbus.types.js';
 export declare class ModbusConfigFlow implements IConfigFlow<IModbusConfig> {
-    start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IModbusConfig>>;
-    private stringValue;
-    private numberValue;
+    #private;
+    constructor(optionsArg?: IModbusIntegrationOptions, scopeArg?: NativeIntegrationScope);
+    start(candidateArg: IDiscoveryCandidate, contextArg: INativeConfigFlowContext): Promise<IConfigFlowStep<IModbusConfig>>;
+    destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
+    private submit;
 }

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

@@ -1,47 +1,79 @@
-const defaultModbusTcpPort = 502;
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
+import { ModbusClient } from './modbus.classes.client.js';
+import { ModbusMapper } from './modbus.mapper.js';
+import { modbusRecord, normalizeModbusConfig } from './modbus.validation.js';
 export class ModbusConfigFlow {
+    #scope;
+    constructor(optionsArg = {}, scopeArg) {
+        this.#scope = scopeArg ?? new NativeIntegrationOwner('modbus', optionsArg).createFlowScope();
+    }
     async start(candidateArg, contextArg) {
-        void contextArg;
+        const candidate = modbusRecord(candidateArg);
+        if (candidate.source !== 'manual' || candidate.integrationDomain !== undefined && candidate.integrationDomain !== 'modbus') {
+            throw new TypeError('Modbus config admission accepts explicit manual candidates only.');
+        }
+        const metadata = candidate.metadata === undefined ? {} : modbusRecord(candidate.metadata);
+        const context = this.#scope.admit(contextArg);
         return {
-            kind: 'form',
-            title: 'Connect Modbus TCP hub',
-            description: 'Configure a known Modbus TCP endpoint. Serial RTU ports are intentionally not guessed or probed.',
+            kind: 'form', title: 'Select Modbus TCP device',
+            description: 'Select the private IPv4 endpoint, unit, vendor and product for the host-selected home. Supply an explicit JSON array of zero-based raw read mappings; writes require single-address permission. Identity strings are unauthenticated LAN observations.',
             fields: [
-                { name: 'name', label: 'Hub name', type: 'text', required: false },
-                { name: 'host', label: 'Host', type: 'text', required: true },
-                { name: 'port', label: 'TCP port', type: 'number', required: false },
-                { name: 'unitId', label: 'Default unit ID', type: 'number', required: false },
-                { name: 'timeoutMs', label: 'Timeout milliseconds', type: 'number', required: false },
+                { name: 'address', label: 'Selected local IPv4 address', type: 'text', required: true },
+                { name: 'port', label: 'TCP port', type: 'number' },
+                { name: 'unitId', label: 'Selected unit ID', type: 'number', required: true },
+                { name: 'expectedVendorName', label: 'Exact vendor name', type: 'text', required: true },
+                { name: 'expectedProductCode', label: 'Exact product code', type: 'text', required: true },
+                { name: 'expectedRevision', label: 'Optional exact revision', type: 'text' },
+                { name: 'allowUnencryptedLan', label: 'Accept unencrypted LAN transport', type: 'boolean', required: true },
+                { name: 'mappings', label: 'Owner raw mappings JSON', type: 'text', required: true },
+                { name: 'name', label: 'Display name', type: 'text' },
             ],
-            submit: async (valuesArg) => {
-                const unitId = this.numberValue(valuesArg.unitId) || this.numberValue(candidateArg.metadata?.unitId) || 1;
-                const port = this.numberValue(valuesArg.port) || candidateArg.port || defaultModbusTcpPort;
-                return {
-                    kind: 'done',
-                    title: 'Modbus TCP hub configured',
-                    config: {
-                        hubs: [{
-                                id: candidateArg.id,
-                                name: this.stringValue(valuesArg.name) || candidateArg.name || 'modbus_hub',
-                                type: 'tcp',
-                                host: this.stringValue(valuesArg.host) || candidateArg.host || '',
-                                port,
-                                timeoutMs: this.numberValue(valuesArg.timeoutMs) || 5000,
-                                slave: unitId,
-                                manufacturer: candidateArg.manufacturer,
-                                model: candidateArg.model,
-                                serialNumber: candidateArg.serialNumber,
-                            }],
-                    },
-                };
-            },
+            submit: (valuesArg) => this.submit(valuesArg, candidate, metadata, context),
         };
     }
-    stringValue(valueArg) {
-        return typeof valueArg === 'string' && valueArg.trim() ? valueArg.trim() : undefined;
-    }
-    numberValue(valueArg) {
-        return typeof valueArg === 'number' && Number.isFinite(valueArg) ? valueArg : typeof valueArg === 'string' && valueArg.trim() && Number.isFinite(Number(valueArg)) ? Number(valueArg) : undefined;
+    destroy() { return this.#scope.close(); }
+    retryCleanup() { return this.#scope.retryCleanup(); }
+    async submit(valuesArg, candidateArg, metadataArg, contextArg) {
+        try {
+            const values = modbusRecord(valuesArg, ['homeId', 'address', 'port', 'unitId', 'expectedVendorName', 'expectedProductCode', 'expectedRevision',
+                'allowUnencryptedLan', 'mappings', 'name', 'localAddress', 'timeoutMs', 'maxQueuedOperations']);
+            if (values.homeId !== undefined && values.homeId !== contextArg.homeId)
+                throw new Error('Modbus submitted home conflicts with the host-selected home.');
+            let mappings = values.mappings;
+            if (typeof mappings === 'string') {
+                if (mappings.length > 32768)
+                    throw new TypeError('Modbus mapping JSON exceeds its size bound.');
+                mappings = JSON.parse(mappings);
+            }
+            const config = normalizeModbusConfig({ ...values, homeId: contextArg.homeId, mappings,
+                address: values.address === undefined ? candidateArg.host : values.address,
+                port: values.port === undefined ? candidateArg.port : values.port,
+                unitId: values.unitId === undefined ? metadataArg.unitId : values.unitId,
+                expectedVendorName: values.expectedVendorName === undefined ? metadataArg.expectedVendorName : values.expectedVendorName,
+                expectedProductCode: values.expectedProductCode === undefined ? metadataArg.expectedProductCode : values.expectedProductCode,
+                expectedRevision: values.expectedRevision === undefined ? metadataArg.expectedRevision : values.expectedRevision });
+            return await this.#scope.run(contextArg, config.homeId, async (leaseArg) => {
+                const client = new ModbusClient(config, leaseArg.signal);
+                let cleanupAttempted = false;
+                leaseArg.own(() => {
+                    if (cleanupAttempted)
+                        return client.retryCleanup();
+                    cleanupAttempted = true;
+                    return client.destroy();
+                });
+                await client.getSnapshot(leaseArg.signal);
+                leaseArg.assertOpen();
+                await client.destroy();
+                leaseArg.assertOpen();
+                if (leaseArg.context.configStore)
+                    await leaseArg.context.configStore.set(`device:${ModbusMapper.deviceId(config)}`, config);
+                leaseArg.assertOpen();
+                return { kind: 'done', title: 'Selected Modbus device and read mappings verified', config };
+            });
+        }
+        catch (errorArg) {
+            return { kind: 'error', title: 'Modbus admission failed', error: errorArg instanceof Error ? errorArg.message : 'Modbus admission failed.' };
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,8 +1,9 @@
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/types.js';
+import type { IIntegrationRuntime, INativeIntegrationSetupContext } from '../../core/types.js';
 import { ModbusConfigFlow } from './modbus.classes.configflow.js';
-import type { IModbusConfig } from './modbus.types.js';
+import type { IModbusConfig, IModbusIntegrationOptions } from './modbus.types.js';
 export declare class ModbusIntegration extends BaseIntegration<IModbusConfig> {
+    #private;
     readonly domain = "modbus";
     readonly displayName = "Modbus";
     readonly status: 'control-runtime';
@@ -10,21 +11,7 @@ export declare class ModbusIntegration extends BaseIntegration<IModbusConfig> {
     readonly configFlow: ModbusConfigFlow;
     readonly metadata: {
         source: string;
-        upstreamPath: string;
         upstreamDomain: string;
-        iotClass: string;
-        requirements: string[];
-        dependencies: never[];
-        afterDependencies: never[];
-        codeowners: never[];
-        documentation: string;
-        configFlow: boolean;
-        discovery: {
-            manual: boolean;
-            tcp: boolean;
-            serial: boolean;
-            note: string;
-        };
         runtime: {
             type: string;
             polling: string;
@@ -35,8 +22,10 @@ export declare class ModbusIntegration extends BaseIntegration<IModbusConfig> {
             explicitUnsupported: string[];
         };
     };
-    setup(configArg: IModbusConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    constructor(optionsArg?: IModbusIntegrationOptions);
+    setup(configArg: IModbusConfig, contextArg: INativeIntegrationSetupContext): Promise<IIntegrationRuntime>;
     destroy(): Promise<void>;
+    retryCleanup(): Promise<void>;
 }
 export declare class HomeAssistantModbusIntegration extends ModbusIntegration {
 }

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

@@ -1,87 +1,163 @@
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { NativeIntegrationOwner } from '../../core/classes.nativeintegrationowner.js';
 import { ModbusClient } from './modbus.classes.client.js';
 import { ModbusConfigFlow } from './modbus.classes.configflow.js';
 import { createModbusDiscoveryDescriptor } from './modbus.discovery.js';
 import { ModbusMapper } from './modbus.mapper.js';
+import { normalizeModbusConfig } from './modbus.validation.js';
 export class ModbusIntegration extends BaseIntegration {
     domain = 'modbus';
     displayName = 'Modbus';
     status = 'control-runtime';
     discoveryDescriptor = createModbusDiscoveryDescriptor();
-    configFlow = new ModbusConfigFlow();
+    configFlow;
     metadata = {
-        source: 'home-assistant/core',
-        upstreamPath: 'homeassistant/components/modbus',
-        upstreamDomain: 'modbus',
-        iotClass: 'local_polling',
-        requirements: ['pymodbus==3.11.2'],
-        dependencies: [],
-        afterDependencies: [],
-        codeowners: [],
-        documentation: 'https://www.home-assistant.io/integrations/modbus',
-        configFlow: true,
-        discovery: {
-            manual: true,
-            tcp: true,
-            serial: false,
-            note: 'Manual Modbus TCP setup is implemented. Serial RTU ports are not guessed or probed.',
-        },
-        runtime: {
-            type: 'control-runtime',
-            polling: 'local snapshot or explicit Modbus TCP requests',
-            services: ['read_coil', 'read_register', 'write_coil', 'write_register', 'stop', 'restart', 'refresh'],
-        },
+        source: 'native', upstreamDomain: 'modbus',
+        runtime: { type: 'control-runtime', polling: 'explicit owner reads', services: ['read', 'write_coil', 'write_register'] },
         localApi: {
-            implemented: [
-                'manual Modbus TCP hub configuration',
-                'snapshot/manual configured registers and coils',
-                'Modbus TCP MBAP request shape for read coils, read discrete inputs, read holding/input registers, write coil(s), and write register(s)',
-                'register/coils mapping to sensor, binary_sensor, switch, and number entities',
-            ],
-            explicitUnsupported: [
-                'unsafe serial RTU discovery or serial port guessing',
-                'serial RTU runtime transport',
-                'RTU-over-TCP framer runtime transport',
-                'UDP runtime transport',
-                'climate, cover, fan, and light platform behavior beyond configured register/coil entities',
-            ],
+            implemented: ['selected home/IPv4/unit/vendor/product', 'fresh basic identity on every operation', 'explicit raw bit/register read mappings',
+                'default-deny single absolute FC5/6 writes', 'bounded devicemanager admission and terminal cleanup'],
+            explicitUnsupported: ['automatic discovery', 'serial RTU', 'UDP', 'RTU-over-TCP', 'register-map inference', 'scaling or semantic device capabilities',
+                'multi-address writes', 'toggles', 'automatic retries or replay', 'cryptographic device authentication', 'physical effect confirmation'],
         },
     };
-    async setup(configArg, contextArg) {
-        void contextArg;
-        return new ModbusRuntime(new ModbusClient(configArg));
+    #owner;
+    constructor(optionsArg = {}) {
+        super();
+        this.#owner = new NativeIntegrationOwner(this.domain, optionsArg);
+        this.configFlow = new ModbusConfigFlow({}, this.#owner.createFlowScope());
+    }
+    setup(configArg, contextArg) {
+        try {
+            const config = normalizeModbusConfig(configArg);
+            return this.#owner.runSetup(contextArg, config.homeId, async (leaseArg) => {
+                const client = new ModbusClient(config, leaseArg.signal);
+                let cleanupAttempted = false;
+                leaseArg.own(() => {
+                    if (cleanupAttempted)
+                        return client.retryCleanup();
+                    cleanupAttempted = true;
+                    return client.destroy();
+                });
+                const snapshot = await client.getSnapshot(leaseArg.signal);
+                leaseArg.assertOpen();
+                const runtime = new ModbusRuntime(client, snapshot, leaseArg);
+                leaseArg.promoteToRuntime();
+                return runtime;
+            });
+        }
+        catch (errorArg) {
+            return Promise.reject(errorArg);
+        }
     }
-    async destroy() { }
+    destroy() { return this.#owner.close(); }
+    retryCleanup() { return this.#owner.retryCleanup(); }
 }
 export class HomeAssistantModbusIntegration extends ModbusIntegration {
 }
 class ModbusRuntime {
     client;
+    snapshot;
+    lease;
     domain = 'modbus';
-    constructor(client) {
+    #subscriptions = new Set();
+    #ownerAbort = () => { void this.destroy().then(() => undefined, () => undefined); };
+    #closed = false;
+    #closing;
+    constructor(client, snapshot, lease) {
         this.client = client;
+        this.snapshot = snapshot;
+        this.lease = lease;
+        lease.signal.addEventListener('abort', this.#ownerAbort, { once: true });
+        if (lease.signal.aborted)
+            this.#ownerAbort();
     }
-    async devices() {
-        return ModbusMapper.toDevices(await this.client.getSnapshot());
+    isHealthy() { return !this.#closed && this.client.isHealthy(); }
+    async devices(signalArg) {
+        return ModbusMapper.toDevices(await this.refresh(signalArg));
     }
-    async entities() {
-        return ModbusMapper.toEntities(await this.client.getSnapshot());
-    }
-    async subscribe(handlerArg) {
-        const unsubscribe = this.client.onEvent((eventArg) => handlerArg(ModbusMapper.toIntegrationEvent(eventArg)));
-        return async () => unsubscribe();
+    async entities() { return ModbusMapper.toEntities(await this.refresh()); }
+    /** Passive observations only: subscribing never starts reads or a polling timer. */
+    async subscribe(handlerArg, signalArg) {
+        this.assertOpen();
+        if (typeof handlerArg !== 'function')
+            throw new TypeError('Modbus subscription handler must be a function.');
+        if (signalArg !== undefined && !(signalArg instanceof AbortSignal))
+            throw new TypeError('Modbus subscription signal must be an AbortSignal.');
+        signalArg?.throwIfAborted();
+        const entry = { handler: handlerArg, release: () => { this.#subscriptions.delete(entry); signalArg?.removeEventListener('abort', entry.release); } };
+        this.#subscriptions.add(entry);
+        signalArg?.addEventListener('abort', entry.release, { once: true });
+        if (signalArg?.aborted)
+            entry.release();
+        return async () => entry.release();
     }
     async callService(requestArg) {
-        const snapshot = await this.client.getSnapshot();
-        const command = ModbusMapper.commandForService(snapshot, requestArg);
-        if (!command) {
-            return { success: false, error: `Unsupported Modbus service: ${requestArg.domain}.${requestArg.service}` };
+        try {
+            this.assertOpen();
+            return await this.execute(ModbusMapper.commandForService(this.client.config, requestArg));
+        }
+        catch (errorArg) {
+            return this.failure(errorArg);
         }
-        const result = await this.client.sendCommand(command);
-        return { success: result.success, error: result.error, data: result.data };
     }
-    async destroy() {
-        await this.client.destroy();
+    async writeFeature(requestArg, signalArg) {
+        try {
+            this.assertOpen();
+            return await this.execute(ModbusMapper.commandForFeature(this.client.config, requestArg), signalArg);
+        }
+        catch (errorArg) {
+            return this.failure(errorArg);
+        }
+    }
+    destroy() {
+        if (this.#closing)
+            return this.#closing;
+        this.#closed = true;
+        this.#closing = Promise.resolve().then(() => this.lease.close());
+        this.lease.signal.removeEventListener('abort', this.#ownerAbort);
+        for (const entry of [...this.#subscriptions])
+            entry.release();
+        return this.#closing;
+    }
+    async refresh(signalArg) {
+        this.assertOpen();
+        const snapshot = await this.client.getSnapshot(signalArg);
+        this.assertOpen();
+        this.snapshot = snapshot;
+        for (const entity of ModbusMapper.toEntities(snapshot))
+            this.notify({ type: 'state_changed', integrationDomain: 'modbus',
+                deviceId: entity.deviceId, entityId: entity.id, timestamp: Date.parse(snapshot.observedAt), data: { entity } });
+        return snapshot;
+    }
+    async execute(commandArg, signalArg) {
+        const result = await this.client.sendCommand(commandArg, signalArg);
+        if ('mapping' in result) {
+            this.assertOpen();
+            const snapshot = { ...this.snapshot, identity: result.identity, observations: [result], observedAt: result.observedAt };
+            const entity = ModbusMapper.toEntities(snapshot)[0];
+            this.notify({ type: 'state_changed', integrationDomain: 'modbus', deviceId: entity.deviceId, entityId: entity.id,
+                timestamp: Date.parse(result.observedAt), data: { entity } });
+        }
+        return { success: true, data: result };
+    }
+    failure(errorArg) {
+        return { success: false, error: errorArg instanceof Error ? errorArg.message : 'Modbus operation failed.',
+            data: { physicalEffectConfirmed: false, effectOutcome: errorArg instanceof plugins.ecobridgeDeviceManager.ModbusProtocolError ? errorArg.effectOutcome : 'not-sent',
+                ...(errorArg instanceof plugins.ecobridgeDeviceManager.ModbusProtocolError ? { errorCode: errorArg.code } : {}) } };
+    }
+    assertOpen() {
+        if (this.#closed)
+            throw new Error('Modbus runtime is destroyed.');
+        this.lease.assertOpen();
+    }
+    notify(eventArg) {
+        for (const entry of [...this.#subscriptions]) {
+            if (this.#closed)
+                break;
+            entry.handler(eventArg);
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modbus.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/modbus/modbus.classes.integration.ts"],"names":[],"mappings":"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"}

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

@@ -2,17 +2,14 @@ import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IDiscoveryCandidate, IDiscoveryContext, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
 import type { IModbusManualTcpEntry } from './modbus.types.js';
 export declare class ModbusManualTcpMatcher implements IDiscoveryMatcher<IModbusManualTcpEntry> {
-    id: string;
-    source: 'manual';
-    description: string;
+    readonly id = "modbus-manual-tcp-match";
+    readonly source: 'manual';
+    readonly description = "Accept explicit Modbus endpoint and family identity selections without network probes.";
     matches(inputArg: IModbusManualTcpEntry, contextArg: IDiscoveryContext): Promise<IDiscoveryMatch>;
-    private normalizedId;
-    private looksLikeSerialPort;
 }
 export declare class ModbusCandidateValidator implements IDiscoveryValidator {
-    id: string;
-    description: string;
+    readonly id = "modbus-candidate-validator";
+    readonly description = "Validate explicit manual selections; live admission belongs to the config flow.";
     validate(candidateArg: IDiscoveryCandidate, contextArg: IDiscoveryContext): Promise<IDiscoveryMatch>;
-    private looksLikeSerialPort;
 }
 export declare const createModbusDiscoveryDescriptor: () => DiscoveryDescriptor;