iobroker.eos-admin 7.9.99 → 7.9.100

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iobroker.eos-admin",
-  "description": "NexoWatt EOS Admin – stable candidate with truthful EMS overview, verified user passwords and deterministic browser updates.",
-  "version": "7.9.99",
+  "description": "NexoWatt EOS Admin – stable sales release with native automatic NexoWatt Stable adapter updates.",
+  "version": "7.9.100",
   "contributors": [
     "bluefox <dogafox@gmail.com>",
     "apollon77",
@@ -118,22 +118,27 @@
     "tools/nexowatt-version-sync-selftest.cjs",
     "tools/nexowatt-merge-update-selftest.cjs",
     "tools/nexowatt-ems-overview-selftest.cjs",
-    "README_STABILITY_V7.9.99.md",
-    "RELEASE_NOTES_V7.9.99.md",
-    "PUBLISH_STABLE_V7.9.99.md",
-    "INSTALL_TEST_V7.9.99.md",
-    "RELEASE_ACCEPTANCE_V7.9.99.md",
-    "MERGE_UPDATE_README_V7.9.99.md",
+    "README_STABILITY_V7.9.100.md",
+    "RELEASE_NOTES_V7.9.100.md",
+    "PUBLISH_STABLE_V7.9.100.md",
+    "INSTALL_TEST_V7.9.100.md",
+    "RELEASE_ACCEPTANCE_V7.9.100.md",
+    "MERGE_UPDATE_README_V7.9.100.md",
     "README_EMS_OVERVIEW_MERGE.md",
     "RC73_EOS_ADMIN_MERGE_VALIDATION.md",
     "VALIDATION_EMS_OVERVIEW_MERGE.md",
     "NexoWatt_EOS_Admin_EMS_OVERVIEW_MERGE_VALIDATION.md",
     "tools/nexowatt-apply-ems-overview.cjs",
     "tools/nexowatt-ui-overview-runtime-selftest.cjs",
-    "tools/nexowatt-stable-v99-selftest.cjs",
+    "tools/nexowatt-stable-v100-selftest.cjs",
     "tools/nexowatt-password-write-selftest.cjs",
     "tools/nexowatt-request-security-selftest.cjs",
-    "tools/nexowatt-cache-update-selftest.cjs"
+    "tools/nexowatt-cache-update-selftest.cjs",
+    "src/lib/eosAutoUpdate.ts",
+    "build/lib/eosAutoUpdate.js",
+    "adminWww/js/eos-auto-update.js",
+    "adminWww/css/eos-auto-update.css",
+    "tools/nexowatt-auto-update-selftest.cjs"
   ],
   "scripts": {
     "npm": "npm i -f && cd src-admin && npm i -f",
@@ -168,7 +173,7 @@
     "nexowatt:repo-entry": "node tools/nexowatt-generate-repo-entry.cjs",
     "nexowatt:patch-repo": "node tools/nexowatt-patch-repo.cjs",
     "nexowatt:repair-update": "node tools/nexowatt-repair-eos-admin-update.cjs",
-    "check:eos-stability": "node tools/nexowatt-stability-check.cjs && node tools/nexowatt-esm-syntax-selftest.cjs && node tools/nexowatt-import-integrity-selftest.cjs && node tools/nexowatt-entrypoint-smoke-selftest.cjs && node tools/nexowatt-frontend-graph-check.cjs && node tools/nexowatt-policy-selftest.cjs && node tools/nexowatt-publish-channel-selftest.cjs && node tools/nexowatt-release-defaults-selftest.cjs && node tools/nexowatt-role-access-selftest.cjs && node tools/nexowatt-internal-reserve-selftest.cjs && node tools/nexowatt-first-login-selftest.cjs && node tools/nexowatt-account-management-selftest.cjs && node tools/nexowatt-cache-update-selftest.cjs && node tools/nexowatt-request-security-selftest.cjs && node tools/nexowatt-password-write-selftest.cjs && node tools/nexowatt-modern-ui-selftest.cjs && node tools/nexowatt-login-layout-selftest.cjs && node tools/nexowatt-branding-selftest.cjs && node tools/nexowatt-default-port-selftest.cjs && node tools/nexowatt-module-popup-selftest.cjs && node tools/nexowatt-datapoint-selftest.cjs && node tools/nexowatt-update-selftest.cjs && node tools/nexowatt-datapoint-interaction-selftest.cjs && node tools/nexowatt-manual-write-policy-selftest.cjs && node tools/nexowatt-value-column-selftest.cjs && node tools/nexowatt-native-shell-selftest.cjs && node tools/nexowatt-assistant-separation-selftest.cjs && node tools/nexowatt-runtime-cleanup-selftest.cjs && node tools/nexowatt-version-sync-selftest.cjs && node tools/nexowatt-merge-update-selftest.cjs && npm run check:eos-stable-v99 && node tools/nexowatt-ems-overview-selftest.cjs && node tools/nexowatt-ui-overview-runtime-selftest.cjs",
+    "check:eos-stability": "node tools/nexowatt-stability-check.cjs && node tools/nexowatt-esm-syntax-selftest.cjs && node tools/nexowatt-import-integrity-selftest.cjs && node tools/nexowatt-entrypoint-smoke-selftest.cjs && node tools/nexowatt-frontend-graph-check.cjs && node tools/nexowatt-policy-selftest.cjs && node tools/nexowatt-publish-channel-selftest.cjs && node tools/nexowatt-release-defaults-selftest.cjs && node tools/nexowatt-role-access-selftest.cjs && node tools/nexowatt-internal-reserve-selftest.cjs && node tools/nexowatt-first-login-selftest.cjs && node tools/nexowatt-account-management-selftest.cjs && node tools/nexowatt-cache-update-selftest.cjs && node tools/nexowatt-request-security-selftest.cjs && node tools/nexowatt-password-write-selftest.cjs && node tools/nexowatt-modern-ui-selftest.cjs && node tools/nexowatt-login-layout-selftest.cjs && node tools/nexowatt-branding-selftest.cjs && node tools/nexowatt-default-port-selftest.cjs && node tools/nexowatt-module-popup-selftest.cjs && node tools/nexowatt-datapoint-selftest.cjs && node tools/nexowatt-update-selftest.cjs && node tools/nexowatt-datapoint-interaction-selftest.cjs && node tools/nexowatt-manual-write-policy-selftest.cjs && node tools/nexowatt-value-column-selftest.cjs && node tools/nexowatt-native-shell-selftest.cjs && node tools/nexowatt-assistant-separation-selftest.cjs && node tools/nexowatt-runtime-cleanup-selftest.cjs && node tools/nexowatt-version-sync-selftest.cjs && node tools/nexowatt-merge-update-selftest.cjs && npm run check:eos-stable-v100 && node tools/nexowatt-ems-overview-selftest.cjs && node tools/nexowatt-ui-overview-runtime-selftest.cjs",
     "nexowatt:patch-built-frontend": "node tools/nexowatt-patch-built-frontend.cjs",
     "clean:eos-runtime": "node tools/nexowatt-clean-legacy-runtime.cjs",
     "precheck:eos-package": "npm run sync:eos-version && npm run prepare:eos-release-defaults && npm run clean:eos-runtime",
@@ -192,10 +197,11 @@
     "sync:eos-version": "node tools/nexowatt-sync-release-version.cjs",
     "test:eos-version-sync": "node tools/nexowatt-version-sync-selftest.cjs",
     "verify:eos-merge": "node tools/nexowatt-merge-update-selftest.cjs",
-    "check:eos-stable-v99": "node tools/nexowatt-stable-v99-selftest.cjs",
     "test:eos-password-write": "node tools/nexowatt-password-write-selftest.cjs",
     "test:eos-request-security": "node tools/nexowatt-request-security-selftest.cjs",
-    "test:eos-cache-update": "node tools/nexowatt-cache-update-selftest.cjs"
+    "test:eos-cache-update": "node tools/nexowatt-cache-update-selftest.cjs",
+    "check:eos-stable-v100": "node tools/nexowatt-stable-v100-selftest.cjs",
+    "check:eos-auto-update": "node tools/nexowatt-auto-update-selftest.cjs"
   },
   "author": "NexoWatt",
   "private": false,
@@ -206,7 +212,7 @@
   },
   "nexowattReleasePolicy": {
     "distTag": "latest",
-    "purpose": "accepted stable NexoWatt EOS sales-product release 7.9.99"
+    "purpose": "accepted stable NexoWatt EOS sales-product release 7.9.100"
   },
   "publisher": "NexoWatt"
 }

package/src/lib/eosAutoUpdate.ts

@@ -0,0 +1,320 @@
+/**
+ * NexoWatt stable adapter auto-update policy manager.
+ *
+ * This class does not install packages itself. It configures ioBroker's native
+ * adapterAutoUpgrade manager so only installed NexoWatt adapters present in the
+ * detected Stable repository receive the `major` policy. All other adapters and
+ * existing user policies are preserved.
+ */
+
+export type NexoWattAutoUpdatePolicy = 'none' | 'patch' | 'minor' | 'major';
+
+interface AdapterObjectLike {
+    _id?: string;
+    common?: Record<string, any>;
+    native?: Record<string, any>;
+}
+
+interface NexoWattAutoUpdateAdapter {
+    namespace: string;
+    host?: string;
+    log: { debug: (message: string) => void; info: (message: string) => void; warn: (message: string) => void; error: (message: string) => void };
+    getForeignObjectAsync: (id: string) => Promise<any>;
+    setForeignObjectAsync: (id: string, object: any, options?: any) => Promise<any>;
+    extendForeignObjectAsync: (id: string, object: any, options?: any) => Promise<any>;
+    getObjectViewAsync: (design: string, search: string, params: any, options?: any) => Promise<any>;
+    sendToHostAsync?: (host: string, command: string, message: any) => Promise<any>;
+}
+
+export interface NexoWattStableUpdateStatus {
+    enabled: boolean;
+    repository: string;
+    managedAdapters: string[];
+    availableStableAdapters: string[];
+    lastSync: number;
+    lastRepositoryRefresh: number;
+    error: string;
+    policy: 'major';
+    source: 'ioBroker-native-auto-upgrade';
+}
+
+interface PersistedState {
+    previousPolicies?: Record<string, NexoWattAutoUpdatePolicy | null>;
+    previousRepositoryEnabled?: boolean | null;
+    previousActiveRepo?: string[];
+    selectedRepository?: string;
+    ownsActiveRepoOrder?: boolean;
+    managedAdapters?: string[];
+    availableStableAdapters?: string[];
+    lastSync?: number;
+    lastRepositoryRefresh?: number;
+    error?: string;
+}
+
+const ADMIN_USER = 'system.user.admin';
+const POLICY: NexoWattAutoUpdatePolicy = 'major';
+const RECONCILE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const REPOSITORY_REFRESH_DELAY_MS = 2500;
+
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const normalizedName = (value: unknown): string => String(value || '').trim().replace(/^system\.adapter\./, '').replace(/\.\d+$/, '');
+const stableVersion = (value: unknown): boolean => /^\d+\.\d+\.\d+$/.test(String(value || '').trim());
+
+export function isNexoWattRepositoryEntry(name: string, entry: any): boolean {
+    const adapterName = normalizedName(entry?.name || name).toLowerCase();
+    if (adapterName === 'eos-admin' || adapterName.startsWith('nexowatt-') || adapterName.startsWith('eos-')) return true;
+    const evidence = JSON.stringify({
+        name,
+        adapterName,
+        title: entry?.title,
+        desc: entry?.desc,
+        author: entry?.author,
+        authors: entry?.authors,
+        publisher: entry?.publisher,
+        url: entry?.url,
+        meta: entry?.meta,
+        readme: entry?.readme,
+        extIcon: entry?.extIcon,
+        licenseInformation: entry?.licenseInformation,
+    }).toLowerCase();
+    return evidence.includes('nexowatt') || evidence.includes('github.com/nexowatt/');
+}
+
+export class NexoWattStableUpdateManager {
+    private timer?: NodeJS.Timeout;
+    private reconcilePromise?: Promise<NexoWattStableUpdateStatus>;
+    private refreshTimer?: NodeJS.Timeout;
+    private retryTimer?: NodeJS.Timeout;
+
+    constructor(private readonly adapter: NexoWattAutoUpdateAdapter) {}
+
+    private get instanceId(): string { return `system.adapter.${this.adapter.namespace}`; }
+
+    async start(): Promise<NexoWattStableUpdateStatus> {
+        const status = await this.reconcile('startup');
+        if (!this.timer) {
+            this.timer = setInterval(() => void this.reconcile('interval'), RECONCILE_INTERVAL_MS);
+            this.timer.unref?.();
+        }
+        return status;
+    }
+
+    stop(): void {
+        if (this.timer) clearInterval(this.timer);
+        if (this.refreshTimer) clearTimeout(this.refreshTimer);
+        if (this.retryTimer) clearTimeout(this.retryTimer);
+        this.timer = undefined;
+        this.refreshTimer = undefined;
+        this.retryTimer = undefined;
+    }
+
+    async getStatus(refresh = false): Promise<NexoWattStableUpdateStatus> {
+        if (refresh) return this.reconcile('status');
+        const instance = await this.adapter.getForeignObjectAsync(this.instanceId);
+        return this.statusFromNative(instance?.native || {});
+    }
+
+    async setEnabled(enabled: boolean): Promise<NexoWattStableUpdateStatus> {
+        await this.adapter.extendForeignObjectAsync(this.instanceId, { native: { eosNexoWattAutoUpdate: enabled } }, { user: ADMIN_USER });
+        return this.reconcile(enabled ? 'enabled' : 'disabled');
+    }
+
+    async reconcile(reason = 'manual'): Promise<NexoWattStableUpdateStatus> {
+        if (this.reconcilePromise) return this.reconcilePromise;
+        this.reconcilePromise = this.reconcileInternal(reason).finally(() => { this.reconcilePromise = undefined; });
+        return this.reconcilePromise;
+    }
+
+    private statusFromNative(native: Record<string, any>): NexoWattStableUpdateStatus {
+        const state = (native.eosNexoWattAutoUpdateState || {}) as PersistedState;
+        return {
+            enabled: native.eosNexoWattAutoUpdate !== false,
+            repository: String(state.selectedRepository || ''),
+            managedAdapters: Array.isArray(state.managedAdapters) ? state.managedAdapters.map(String).sort() : [],
+            availableStableAdapters: Array.isArray(state.availableStableAdapters) ? state.availableStableAdapters.map(String).sort() : [],
+            lastSync: Number(state.lastSync || 0),
+            lastRepositoryRefresh: Number(state.lastRepositoryRefresh || 0),
+            error: String(state.error || ''),
+            policy: POLICY,
+            source: 'ioBroker-native-auto-upgrade',
+        };
+    }
+
+    private async reconcileInternal(reason: string): Promise<NexoWattStableUpdateStatus> {
+        const instance = await this.adapter.getForeignObjectAsync(this.instanceId);
+        const native = instance?.native || {};
+        const enabled = native.eosNexoWattAutoUpdate !== false;
+        const state = clone((native.eosNexoWattAutoUpdateState || {}) as PersistedState);
+        try {
+            if (!enabled) return await this.disable(state, reason);
+            return await this.enable(state, reason);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error || 'unknownError');
+            state.error = message;
+            state.lastSync = Date.now();
+            await this.persist(enabled, state);
+            if (enabled) this.scheduleRetry();
+            this.adapter.log.warn(`[NexoWatt stable updates] ${message}`);
+            return this.statusFromNative({ eosNexoWattAutoUpdate: enabled, eosNexoWattAutoUpdateState: state });
+        }
+    }
+
+    private async readInstalledAdapters(): Promise<Map<string, AdapterObjectLike>> {
+        const view = await this.adapter.getObjectViewAsync('system', 'adapter', {
+            startkey: 'system.adapter.',
+            endkey: 'system.adapter.\u9999',
+        }, { user: ADMIN_USER });
+        const result = new Map<string, AdapterObjectLike>();
+        for (const row of view?.rows || []) {
+            const object = row?.value || row?.doc;
+            const name = normalizedName(object?.common?.name || row?.id || object?._id);
+            if (name && object?.common?.version) result.set(name, object);
+        }
+        return result;
+    }
+
+    private async readRepositorySelection(systemConfig: any): Promise<{ name: string; entries: Record<string, any>; stableNames: string[] }> {
+        const repositories = await this.adapter.getForeignObjectAsync('system.repositories');
+        const rows = repositories?.native?.repositories || {};
+        const active = Array.isArray(systemConfig?.common?.activeRepo) ? systemConfig.common.activeRepo.map(String) : [];
+        const candidates = Object.entries(rows).map(([name, repo]: [string, any]) => {
+            const entries = repo?.json && typeof repo.json === 'object' ? repo.json : {};
+            const stableNames = Object.entries(entries)
+                .filter(([entryName, entry]) => stableVersion((entry as any)?.version) && isNexoWattRepositoryEntry(entryName, entry))
+                .map(([entryName, entry]) => normalizedName((entry as any)?.name || entryName))
+                .filter(Boolean);
+            return { name, entries, stableNames: [...new Set(stableNames)].sort(), activeIndex: active.indexOf(name) };
+        }).filter(row => row.stableNames.length > 0);
+        if (!candidates.length) throw new Error('nexowattStableRepositoryNotFound');
+        candidates.sort((a, b) => {
+            const aa = a.activeIndex < 0 ? Number.MAX_SAFE_INTEGER : a.activeIndex;
+            const bb = b.activeIndex < 0 ? Number.MAX_SAFE_INTEGER : b.activeIndex;
+            return aa - bb || b.stableNames.length - a.stableNames.length || a.name.localeCompare(b.name);
+        });
+        return candidates[0];
+    }
+
+    private async enable(state: PersistedState, reason: string): Promise<NexoWattStableUpdateStatus> {
+        const systemConfig = await this.adapter.getForeignObjectAsync('system.config');
+        if (!systemConfig?.common) throw new Error('systemConfigUnavailable');
+        const selected = await this.readRepositorySelection(systemConfig);
+        const installed = await this.readInstalledAdapters();
+        const managedNames = selected.stableNames.filter(name => installed.has(name)).sort();
+        if (!managedNames.length) throw new Error('noInstalledNexoWattStableAdapters');
+
+        state.previousPolicies ||= {};
+        for (const name of managedNames) {
+            if (!(name in state.previousPolicies)) {
+                const current = installed.get(name)?.common?.automaticUpgrade;
+                state.previousPolicies[name] = current == null ? null : current as NexoWattAutoUpdatePolicy;
+            }
+            await this.writeAdapterPolicy(name, POLICY);
+        }
+
+        const common = systemConfig.common;
+        const activeRepo = Array.isArray(common.activeRepo) ? [...common.activeRepo] : [];
+        const auto = common.adapterAutoUpgrade && typeof common.adapterAutoUpgrade === 'object'
+            ? clone(common.adapterAutoUpgrade)
+            : { repositories: {}, defaultPolicy: 'none' };
+        auto.repositories = auto.repositories && typeof auto.repositories === 'object' ? { ...auto.repositories } : {};
+        if (state.previousRepositoryEnabled === undefined) {
+            state.previousRepositoryEnabled = Object.prototype.hasOwnProperty.call(auto.repositories, selected.name)
+                ? Boolean(auto.repositories[selected.name])
+                : null;
+        }
+        auto.repositories[selected.name] = true;
+        if (!auto.defaultPolicy) auto.defaultPolicy = 'none';
+        common.adapterAutoUpgrade = auto;
+
+        if (activeRepo[0] !== selected.name) {
+            if (!state.previousActiveRepo) state.previousActiveRepo = [...activeRepo];
+            state.ownsActiveRepoOrder = true;
+            common.activeRepo = [selected.name, ...activeRepo.filter((name: string) => name !== selected.name)];
+        }
+        await this.adapter.setForeignObjectAsync('system.config', systemConfig, { user: ADMIN_USER });
+
+        state.selectedRepository = selected.name;
+        state.availableStableAdapters = selected.stableNames;
+        state.managedAdapters = managedNames;
+        state.lastSync = Date.now();
+        state.error = '';
+        await this.persist(true, state);
+        this.scheduleRepositoryRefresh(selected.name, state);
+        this.adapter.log.info(`[NexoWatt stable updates] Enabled for ${managedNames.join(', ')} from repository "${selected.name}" (${reason})`);
+        return this.statusFromNative({ eosNexoWattAutoUpdate: true, eosNexoWattAutoUpdateState: state });
+    }
+
+    private async disable(state: PersistedState, reason: string): Promise<NexoWattStableUpdateStatus> {
+        for (const [name, previous] of Object.entries(state.previousPolicies || {})) {
+            const current = await this.adapter.getForeignObjectAsync(`system.adapter.${normalizedName(name)}`);
+            if (current?.common?.automaticUpgrade === POLICY) await this.writeAdapterPolicy(name, previous);
+        }
+        const systemConfig = await this.adapter.getForeignObjectAsync('system.config');
+        if (systemConfig?.common) {
+            const auto = systemConfig.common.adapterAutoUpgrade && typeof systemConfig.common.adapterAutoUpgrade === 'object'
+                ? clone(systemConfig.common.adapterAutoUpgrade)
+                : null;
+            if (auto && state.selectedRepository) {
+                auto.repositories = auto.repositories && typeof auto.repositories === 'object' ? { ...auto.repositories } : {};
+                if (auto.repositories[state.selectedRepository] === true) {
+                    if (state.previousRepositoryEnabled === null || state.previousRepositoryEnabled === undefined) delete auto.repositories[state.selectedRepository];
+                    else auto.repositories[state.selectedRepository] = state.previousRepositoryEnabled;
+                }
+                systemConfig.common.adapterAutoUpgrade = auto;
+            }
+            if (state.ownsActiveRepoOrder && Array.isArray(state.previousActiveRepo)
+                && Array.isArray(systemConfig.common.activeRepo)
+                && systemConfig.common.activeRepo[0] === state.selectedRepository) {
+                systemConfig.common.activeRepo = [...state.previousActiveRepo];
+            }
+            await this.adapter.setForeignObjectAsync('system.config', systemConfig, { user: ADMIN_USER });
+        }
+        state.previousPolicies = {};
+        state.previousRepositoryEnabled = undefined;
+        state.previousActiveRepo = undefined;
+        state.ownsActiveRepoOrder = false;
+        state.managedAdapters = [];
+        state.lastSync = Date.now();
+        state.error = '';
+        await this.persist(false, state);
+        this.adapter.log.info(`[NexoWatt stable updates] Disabled and previous policies restored (${reason})`);
+        return this.statusFromNative({ eosNexoWattAutoUpdate: false, eosNexoWattAutoUpdateState: state });
+    }
+
+    private async writeAdapterPolicy(name: string, policy: NexoWattAutoUpdatePolicy | null): Promise<void> {
+        const id = `system.adapter.${normalizedName(name)}`;
+        const object = await this.adapter.getForeignObjectAsync(id);
+        if (!object?.common) return;
+        if (policy === null) delete object.common.automaticUpgrade;
+        else object.common.automaticUpgrade = policy;
+        await this.adapter.setForeignObjectAsync(id, object, { user: ADMIN_USER });
+    }
+
+    private async persist(enabled: boolean, state: PersistedState): Promise<void> {
+        await this.adapter.extendForeignObjectAsync(this.instanceId, {
+            native: { eosNexoWattAutoUpdate: enabled, eosNexoWattAutoUpdateState: state },
+        }, { user: ADMIN_USER });
+    }
+
+    private scheduleRetry(): void {
+        if (this.retryTimer) clearTimeout(this.retryTimer);
+        this.retryTimer = setTimeout(() => void this.reconcile('retry'), 60_000);
+        this.retryTimer.unref?.();
+    }
+
+    private scheduleRepositoryRefresh(repository: string, state: PersistedState): void {
+        if (!this.adapter.sendToHostAsync || !this.adapter.host) return;
+        if (this.refreshTimer) clearTimeout(this.refreshTimer);
+        this.refreshTimer = setTimeout(() => {
+            void this.adapter.sendToHostAsync?.(this.adapter.host!, 'getRepository', { repo: repository, update: true })
+                .then(async () => {
+                    const current = await this.adapter.getForeignObjectAsync(this.instanceId);
+                    if (current?.native?.eosNexoWattAutoUpdate === false) return;
+                    state.lastRepositoryRefresh = Date.now();
+                    await this.persist(true, state);
+                })
+                .catch(error => this.adapter.log.warn(`[NexoWatt stable updates] Repository refresh failed: ${error instanceof Error ? error.message : error}`));
+        }, REPOSITORY_REFRESH_DELAY_MS);
+        this.refreshTimer.unref?.();
+    }
+}

package/tools/nexowatt-account-management-selftest.cjs

@@ -12,7 +12,7 @@ for(const code of [webSource,webBuilt]){
   must(!code.includes('setForeignObjectAsync(targetUserId, user)'),'reset still writes stale full user object');
 }
 for(const marker of ['setPasswordAsync(userName','checkPasswordAsync(userName','passwordNotPersisted','passwordVerificationFailed'])must(passwordSource.includes(marker),`password helper marker missing: ${marker}`);
-for(const marker of ["VERSION = 'v99-account-management-password-write'","['admin', 'installer']",'nexowatt/account/manage','nexowatt/account/reset','X-NexoWatt-EOS-Account-Reset','data.canResetInstaller === true',"account.role === 'enduser'",'Admin/Service','Installateure','NEXOWATT_EOS_ACCOUNT_MANAGEMENT','ensureEntrySurface',"currentRoute() !== 'tab-users'",'eos-account-management-entry','Startpasswort „nexowatt“','passwordVerificationFailed'])must(sourceUi.includes(marker),`UI marker missing: ${marker}`);
+for(const marker of ["VERSION = 'v100-account-management-password-write'","['admin', 'installer']",'nexowatt/account/manage','nexowatt/account/reset','X-NexoWatt-EOS-Account-Reset','data.canResetInstaller === true',"account.role === 'enduser'",'Admin/Service','Installateure','NEXOWATT_EOS_ACCOUNT_MANAGEMENT','ensureEntrySurface',"currentRoute() !== 'tab-users'",'eos-account-management-entry','Startpasswort „nexowatt“','passwordVerificationFailed'])must(sourceUi.includes(marker),`UI marker missing: ${marker}`);
 must(sourceUi===builtUi,'account management source/build drift');
 must(!sourceUi.includes("launcher.className = 'eos-account-management-launcher'"),'standalone account launcher remains');
 must(!sourceUi.includes('new MutationObserver'),'account management adds a broad observer');

package/tools/nexowatt-auto-update-selftest.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+const assert=require('node:assert/strict');
+const {NexoWattStableUpdateManager,isNexoWattRepositoryEntry}=require('../build/lib/eosAutoUpdate.js');
+const objects=new Map();
+objects.set('system.adapter.eos-admin.0',{_id:'system.adapter.eos-admin.0',common:{name:'eos-admin',version:'7.9.100'},native:{eosNexoWattAutoUpdate:true}});
+objects.set('system.config',{_id:'system.config',common:{activeRepo:['stable'],adapterAutoUpgrade:{repositories:{stable:false},defaultPolicy:'none'}},native:{}});
+objects.set('system.repositories',{_id:'system.repositories',native:{repositories:{stable:{json:{'eos-admin':{name:'eos-admin',version:'7.9.100',meta:'https://github.com/NexoWatt/ioBroker.eos-admin'},'nexowatt-ui':{name:'nexowatt-ui',version:'0.8.198',publisher:'NexoWatt'},'nexowatt-beta':{name:'nexowatt-beta',version:'1.0.0-beta.1',publisher:'NexoWatt'},admin:{name:'admin',version:'7.7.0',publisher:'ioBroker'}}}}}});
+objects.set('system.adapter.eos-admin',{_id:'system.adapter.eos-admin',common:{name:'eos-admin',version:'7.9.100',automaticUpgrade:'patch'},native:{}});
+objects.set('system.adapter.nexowatt-ui',{_id:'system.adapter.nexowatt-ui',common:{name:'nexowatt-ui',version:'0.8.197'},native:{}});
+objects.set('system.adapter.admin',{_id:'system.adapter.admin',common:{name:'admin',version:'7.7.0',automaticUpgrade:'minor'},native:{}});
+const copy=v=>JSON.parse(JSON.stringify(v));
+const refresh=[];
+const adapter={namespace:'eos-admin.0',host:'eos-host',log:{debug(){},info(){},warn(){},error(){}},getForeignObjectAsync:async id=>copy(objects.get(id)||null),setForeignObjectAsync:async(id,obj)=>{objects.set(id,copy(obj));},extendForeignObjectAsync:async(id,part)=>{const base=copy(objects.get(id)||{_id:id,common:{},native:{}});base.native={...(base.native||{}),...(part.native||{})};base.common={...(base.common||{}),...(part.common||{})};objects.set(id,base);},getObjectViewAsync:async()=>({rows:[...objects.entries()].filter(([id])=>/^system\.adapter\.[^.]+$/.test(id)).map(([id,value])=>({id,value:copy(value)}))}),sendToHostAsync:async(...args)=>{refresh.push(args);}};
+(async()=>{
+ assert.equal(isNexoWattRepositoryEntry('nexowatt-ui',{publisher:'NexoWatt'}),true);
+ assert.equal(isNexoWattRepositoryEntry('admin',{publisher:'ioBroker'}),false);
+ const manager=new NexoWattStableUpdateManager(adapter);
+ const enabled=await manager.reconcile('test');
+ assert.equal(enabled.enabled,true);assert.equal(enabled.repository,'stable');assert.deepEqual(enabled.managedAdapters,['eos-admin','nexowatt-ui']);
+ assert.equal(objects.get('system.adapter.eos-admin').common.automaticUpgrade,'major');
+ assert.equal(objects.get('system.adapter.nexowatt-ui').common.automaticUpgrade,'major');
+ assert.equal(objects.get('system.adapter.admin').common.automaticUpgrade,'minor');
+ assert.equal(objects.get('system.config').common.adapterAutoUpgrade.repositories.stable,true);
+ // A manual user change while EOS management is active must not be overwritten on disable.
+ objects.get('system.adapter.nexowatt-ui').common.automaticUpgrade='minor';
+ const disabled=await manager.setEnabled(false);assert.equal(disabled.enabled,false);
+ assert.equal(objects.get('system.adapter.eos-admin').common.automaticUpgrade,'patch');
+ assert.equal(objects.get('system.adapter.nexowatt-ui').common.automaticUpgrade,'minor');
+ assert.equal(objects.get('system.adapter.admin').common.automaticUpgrade,'minor');
+ assert.equal(objects.get('system.config').common.adapterAutoUpgrade.repositories.stable,false);
+ manager.stop();
+ console.log('[NexoWatt EOS auto update] OK (native policy, stable-only scope, third-party isolation and restore)');
+})().catch(e=>{console.error(e.stack||e);process.exit(1)});

package/tools/nexowatt-cache-update-selftest.cjs

@@ -2,10 +2,11 @@
 'use strict';
 const fs=require('node:fs');const path=require('node:path');const root=path.resolve(__dirname,'..');
 const read=rel=>fs.readFileSync(path.join(root,rel),'utf8');const fail=m=>{console.error(`[NexoWatt EOS cache update] ${m}`);process.exit(1)};const must=(c,m)=>{if(!c)fail(m)};
-const source=read('src/lib/web.ts'),built=read('build/lib/web.js'),index=read('adminWww/index.html'),dev=read('src-admin/index.html'),watch=read('adminWww/js/eos-release-watch.js');
+const source=read('src/lib/web.ts'),built=read('build/lib/web.js'),index=read('adminWww/index.html'),dev=read('src-admin/index.html'),watch=read('adminWww/js/eos-release-watch.js'),pkg=JSON.parse(read('package.json')),info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));
+const release=pkg.version,tag=String(info.shellCacheTag||info.shellCacheVersion),shell=Number(info.shellCacheVersion);
 for(const code of [source,built])for(const marker of ['isEosCurrentAsset','applyNoStoreHeaders','Surrogate-Control','this.indexHTML = await this.prepareIndex'])must(code.includes(marker),`server marker missing: ${marker}`);
-for(const marker of ["const RELEASE = '7.9.99'",'nexowatt.eos.loadedRelease','cache: \'no-store\'','window.location.replace','navigator.serviceWorker?.getRegistrations'])must(watch.includes(marker),`watcher marker missing: ${marker}`);
-for(const html of [index,dev])for(const marker of ['eos-release-watch.js?v=99','nexowatt-stable-v99.js?v=99','nexowatt-native-shell.css?v=99'])must(html.includes(marker),`index marker missing: ${marker}`);
-must(index.includes('hostInit-v84.js?v=99')&&index.includes('index-CQZugZ1z-v84.js?v=99'),'productive module entry cache tags missing');
-must(!/\?v=(?:97|98)(?:["'])/.test(index),'stale product cache tag remains');
+for(const marker of [`const RELEASE = '${release}'`,'nexowatt.eos.loadedRelease','cache: \'no-store\'','window.location.replace','navigator.serviceWorker?.getRegistrations'])must(watch.includes(marker),`watcher marker missing: ${marker}`);
+for(const html of [index,dev])for(const marker of [`eos-release-watch.js?v=${tag}`,`nexowatt-stable-v${shell}.js?v=${tag}`,`nexowatt-native-shell.css?v=${tag}`])must(html.includes(marker),`index marker missing: ${marker}`);
+must(index.includes(`hostInit-v84.js?v=${tag}`)&&index.includes(`index-CQZugZ1z-v84.js?v=${tag}`),'productive module entry cache tags missing');
+must(!/\?v=(?:97|98|99)(?:["'])/.test(index),'stale product cache tag remains');
 console.log('[NexoWatt EOS cache update] OK (no-store entrypoints and release watcher)');

package/tools/nexowatt-login-layout-selftest.cjs

@@ -3,12 +3,12 @@
 const fs=require('node:fs');const path=require('node:path');const root=path.resolve(__dirname,'..');
 const read=rel=>fs.readFileSync(path.join(root,rel),'utf8');const fail=m=>{console.error(`[NexoWatt EOS login layout] ${m}`);process.exit(1)};const must=(c,m)=>{if(!c)fail(m)};
 const css=read('adminWww/css/nexowatt-native-shell.css'),sourceCss=read('src-admin/public/css/nexowatt-native-shell.css');
-const login=read('src-admin/src/login/Login.tsx'),stableLogin=read('adminWww/static/js/nexowatt-stable-login.js'),stable=read('adminWww/static/js/nexowatt-stable-v99.js'),index=read('adminWww/index.html'),info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));
+const login=read('src-admin/src/login/Login.tsx'),stableLogin=read('adminWww/static/js/nexowatt-stable-login.js'),stable=read('adminWww/static/js/nexowatt-stable-v100.js'),index=read('adminWww/index.html'),info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));
 must(css===sourceCss,'login CSS source/build drift');
 for(const marker of ['outer frame is decorative only','orderly login, moderately enlarged','width: min(440px, calc(100vw - 20px)) !important','height: min(580px, calc(100dvh - 20px)) !important','width: min(380px, calc(100vw - 52px)) !important','min-height: 510px !important','height: auto !important','overflow: visible !important'])must(css.includes(marker),`login marker missing: ${marker}`);
 must(!css.includes('width: min(520px, calc(100vw - 24px))')&&!css.includes('width: min(460px, calc(100vw - 56px))'),'oversized v96 geometry remains');
 must(!/data-nw-login-card|data-nw-login-shell|min-height:590px|width:min\(460px|createElement\(['"]style/.test(stableLogin),'stable-login runtime mutates geometry');
-must(!/width:min\(460px|min-height:540px|createElement\(['"]style/.test(stable),'stable v99 runtime injects login geometry');
+must(!/width:min\(460px|min-height:540px|createElement\(['"]style/.test(stable),'stable v100 runtime injects login geometry');
 must(login.includes('minHeight: 510')&&login.includes("overflowY: 'visible'")&&login.includes("maxHeight: 'none'"),'native Login source does not match product contract');
-must(index.includes(`nexowatt-native-shell.css?v=${info.shellCacheTag}`)&&index.includes('nexowatt-stable-v99.js?v=99'),'v99 login assets not active');
+must(index.includes(`nexowatt-native-shell.css?v=${info.shellCacheTag}`)&&index.includes('nexowatt-stable-v100.js?v=100'),'v100 login assets not active');
 console.log('[NexoWatt EOS login layout] OK');

package/tools/nexowatt-merge-update-selftest.cjs

@@ -16,7 +16,7 @@ for (const file of [
     'MERGE_UPDATE.ps1',
     'MERGE_UPDATE.cmd',
     'MERGE_UPDATE.sh',
-    'MERGE_UPDATE_README_V7.9.99.md',
+    'MERGE_UPDATE_README_V7.9.100.md',
     'tools/nexowatt-apply-ems-overview.cjs',
     'tools/nexowatt-sync-release-version.cjs',
     'tools/nexowatt-version-sync-selftest.cjs',

package/tools/nexowatt-modern-ui-selftest.cjs

@@ -29,7 +29,7 @@ for (const marker of ['eos-account-management.js','nexowatt-native-shell.css','e
 for (const marker of ['NexoWatt EOS', 'Zugänge & Rollen', 'Endkunden-Zugänge', 'ensureEntrySurface']) {
   if (!accountUi.includes(marker)) fail(`modern account surface missing label: ${marker}`);
 }
-for (const marker of ['installIntegratedFirstLogin','v99 normal-login first activation','eos-passwordless-card','Idempotent writes are essential here']) {
+for (const marker of ['installIntegratedFirstLogin','v100 normal-login first activation','eos-passwordless-card','Idempotent writes are essential here']) {
   if (!bootstrap.includes(marker)) fail(`integrated first-activation surface missing: ${marker}`);
 }
 if (/data-eos-account=|selector\.innerHTML/.test(bootstrap)) fail('compact login still injects role buttons or a second panel');

package/tools/nexowatt-runtime-cleanup-selftest.cjs

@@ -15,15 +15,15 @@ try {
   fs.mkdirSync(path.join(temp, 'src-admin', 'public', 'js'), { recursive: true });
   fs.mkdirSync(path.join(temp, 'src-admin', 'public', 'static', 'js'), { recursive: true });
   fs.mkdirSync(path.join(temp, 'adminWww', 'static', 'js'), { recursive: true });
-  fs.writeFileSync(path.join(temp, 'NEXOWATT_EOS_BUILD_INFO.json'), JSON.stringify({ runtimeEntry: 'v82', shellCacheVersion: 99 }));
+  fs.writeFileSync(path.join(temp, 'NEXOWATT_EOS_BUILD_INFO.json'), JSON.stringify({ runtimeEntry: 'v82', shellCacheVersion: 100 }));
 
   const keep = [
     'adminWww/assets/bootstrap-current-v82.js',
     'adminWww/assets/Objects-current-v82.js',
     'adminWww/remoteEntry-v82.js',
     'adminWww/remoteEntry.js',
-    'adminWww/static/js/nexowatt-stable-v99.js',
-    'src-admin/public/static/js/nexowatt-stable-v99.js',
+    'adminWww/static/js/nexowatt-stable-v100.js',
+    'src-admin/public/static/js/nexowatt-stable-v100.js',
     'adminWww/static/js/nexowatt-stable-login.js',
   ];
   const remove = [
@@ -45,7 +45,7 @@ try {
 
   const result = cleanLegacyRuntime({ root: temp, quiet: true, silent: true });
   assert.strictEqual(result.activeRuntime, 82);
-  assert.strictEqual(result.activeShell, 99);
+  assert.strictEqual(result.activeShell, 100);
   assert.strictEqual(result.removed.length, remove.length);
   for (const rel of keep) assert.ok(fs.existsSync(path.join(temp, rel)), `current runtime removed: ${rel}`);
   for (const rel of remove) assert.ok(!fs.existsSync(path.join(temp, rel)), `legacy file remained: ${rel}`);

package/tools/nexowatt-stable-v100-selftest.cjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict';
+const fs=require('node:fs'),path=require('node:path');
+const root=path.resolve(__dirname,'..');
+const read=r=>fs.readFileSync(path.join(root,r),'utf8');
+const must=(c,m)=>{if(!c){console.error(`[NexoWatt EOS stable v100] ${m}`);process.exit(1)}};
+const pkg=JSON.parse(read('package.json'));
+const io=JSON.parse(read('io-package.json'));
+const info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));
+const source=read('src/lib/eosAutoUpdate.ts');
+const built=read('build/lib/eosAutoUpdate.js');
+const web=read('src/lib/web.ts');
+const webBuilt=read('build/lib/web.js');
+const ui=read('adminWww/js/eos-auto-update.js');
+const index=read('adminWww/index.html');
+must(pkg.version==='7.9.100'&&io.version==='7.9.100'&&io.common.version==='7.9.100'&&info.version==='7.9.100','version drift');
+must(io.native.eosNexoWattAutoUpdate===true,'auto update is not enabled by default');
+for(const marker of ['adapterAutoUpgrade','automaticUpgrade','isNexoWattRepositoryEntry','previousPolicies','previousRepositoryEnabled','getRepository']){
+  must(source.includes(marker)&&built.includes(marker),`manager marker missing: ${marker}`);
+}
+must(source.includes("const POLICY: NexoWattAutoUpdatePolicy = 'major'")&&built.includes("const POLICY = 'major'"),'manager major policy marker missing');
+must(source.includes("auto.defaultPolicy = 'none'")&&source.includes('stableVersion'),'non-NexoWatt/stable isolation missing');
+must(web.includes('/nexowatt/updates/status')&&web.includes('/nexowatt/updates/settings')&&webBuilt.includes('/nexowatt/updates/settings'),'update API missing');
+must(ui.includes('Automatische Adapter-Updates')&&ui.includes('X-NexoWatt-EOS-Auto-Update')&&ui.includes('jederzeit änderbar'),'admin toggle missing');
+must(index.includes('eos-auto-update.css?v=100')&&index.includes('eos-auto-update.js?v=100')&&index.includes('nexowatt-stable-v100.js?v=100'),'v100 assets missing');
+must(!index.includes('?v=99')&&!index.includes('stable-v99'),'stale v99 browser assets active');
+console.log('[NexoWatt EOS stable v100] OK');

package/tools/nexowatt-ui-overview-runtime-selftest.cjs

@@ -5,7 +5,7 @@ const runtime=read('adminWww/js/eos-ems-overview.js');const source=read('src-adm
 if(runtime!==source)fail('runtime source/build drift');
 for(const marker of ['nexowatt-ems-overview-v1','nexowatt-ui.*.info.adminOverview.*','system.adapter.nexowatt-ui.*.alive','POLL_MS = 5000','STALE_MS = 20000',"REQUIRED_UI_VERSION = '0.8.198'",'getForeignStates','Keine Kachel besitzt Schreibhoheit','currentDecisions','§14a-Fallback','nexowatt-eos-admin-socket-ready','readUiAdapterInfo','socketFromReact'])if(!runtime.includes(marker))fail(`runtime marker missing: ${marker}`);
 for(const forbidden of ['setForeignState','setState(','sendToHost','writeFile','extendObject'])if(runtime.includes(forbidden))fail(`read-only runtime contains ${forbidden}`);
-for(const marker of ['eos-ems-overview.css?v=99','eos-ems-overview.js?v=99','nexowatt-stable-v99.js?v=99','eos-release-watch.js?v=99'])if(!index.includes(marker))fail(`index marker missing: ${marker}`);
+for(const marker of ['eos-ems-overview.css?v=100','eos-ems-overview.js?v=100','nexowatt-stable-v100.js?v=100','eos-release-watch.js?v=100'])if(!index.includes(marker))fail(`index marker missing: ${marker}`);
 if(runtime.includes('Vollständige EMS-Diagnose öffnen'))fail('unsupported EMS destination remains visible');
 if(!intro.includes('eos-overview-edit-controls')||!introBundle.includes('eos-overview-edit-controls'))fail('edit control is not inside bottom card grid');
 if(!css.includes('#eos-ems-overview-runtime')||!css.includes('.eos-ems-overview-metrics')||!css.includes('startup and compatibility messages stay compact'))fail('EMS card CSS incomplete');