iobroker.eos-admin 7.9.99 → 7.10.0

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

@@ -11,8 +11,8 @@ for(const code of [webSource,webBuilt]){
   must(!code.includes('const explicitEndUser = targetAccess.groups.some'),'obsolete explicit end-user re-classifier remains');
   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 ['apiTarget: normalized.userId','apiTarget: normalized.userName','verifyAfterWrite','passwordNotPersisted','passwordVerificationFailed'])must(passwordSource.includes(marker),`password helper marker missing: ${marker}`);
+for(const marker of ["VERSION = 'v7100-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.10.0'},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.10.0',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.10.0',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

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 '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 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 fs=require('node:fs'),path=require('node:path');const root=path.resolve(__dirname,'..');const read=r=>fs.readFileSync(path.join(root,r),'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'),login=read('src-admin/src/login/Login.tsx'),bundle=read('adminWww/assets/bootstrap-COulQZax-v84.js'),boot=read('adminWww/js/eos-role-bootstrap.js'),stableLogin=read('adminWww/static/js/nexowatt-stable-login.js'),stable=read('adminWww/static/js/nexowatt-stable-v7100.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}`);
+for(const marker of ['NexoWatt EOS 7.10.0 – restored clean login geometry','NexoWatt EOS 7.10.0 final – static labels above login fields','width: min(424px, calc(100vw - 20px)) !important','width: min(372px, calc(100vw - 48px)) !important','position: static !important','transform: none !important','display: none !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(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');
-console.log('[NexoWatt EOS login layout] OK');
+must(stableLogin.includes('normalizeGeometry')&&stableLogin.includes('MuiInputLabel-shrink')&&stableLogin.includes("removeAttribute('data-nw-login-card')")&&stableLogin.includes("removeAttribute('aria-hidden')"),'login cleanup/static-label runtime missing');
+must(!/setAttribute\(['"]data-nw-login-card|createElement\(['"]style/.test(stableLogin),'stable-login runtime creates geometry attributes/styles');
+must(!/width:min\(460px|min-height:540px|createElement\(['"]style/.test(stable),'stable runtime injects login geometry');
+must(boot.includes("const card = form?.closest?.('.MuiPaper-root')")&&!boot.includes("closest?.('.MuiPaper-root,form,main,section')"),'login Paper ownership incorrect');
+must(login.includes('minHeight: 0')&&login.includes('maxWidth: 372')&&login.includes("marginTop: 18")&&login.includes('width: 90')&&(login.match(/inputLabel: \{ shrink: true \}/g)||[]).length>=2,'native Login source does not match product contract');
+for(const marker of ['p:"26px 28px 24px"','width:"calc(100% - 48px)"','maxWidth:372','width:90,height:90','marginTop:18','inputLabel:{shrink:!0}'])must(bundle.includes(marker),`productive login bundle marker missing: ${marker}`);
+must(index.includes(`nexowatt-native-shell.css?v=${info.shellCacheTag}`)&&index.includes('nexowatt-stable-v7100.js?v=7100'),'v7100 login assets not active');
+console.log('[NexoWatt EOS login layout] OK (single Paper, static labels, compact responsive geometry)');

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.10.0.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','v7100 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-password-write-selftest.cjs

@@ -1,46 +1,18 @@
 #!/usr/bin/env node
 'use strict';
 const assert=require('node:assert/strict');
-const fs=require('node:fs');
-const path=require('node:path');
-const {normalizeEosPasswordTarget,setEosUserPasswordWithVerification}=require('../build/lib/eosPassword.js');
-const root=path.resolve(__dirname,'..');
-const source=fs.readFileSync(path.join(root,'src/lib/eosPassword.ts'),'utf8');
-const web=fs.readFileSync(path.join(root,'src/lib/web.ts'),'utf8');
-
-function adapterFixture({verify=true,persist=true,callback=false}={}){
-  let password='old';
-  let hash=persist?'$old':'';
-  const calls=[];
-  const adapter={
-    calls,
-    getForeignObjectAsync:async id=>id==='system.user.user'?{_id:id,common:{password:hash},native:{}}:null,
-    checkPasswordAsync:async (user,value,options)=>{calls.push({kind:'check',user,value,options});return [verify&&user==='user'&&value===password,'system.user.user'];},
-  };
-  const set=async(user,value,options)=>{calls.push({kind:'set',user,value,options});if(user!=='user')throw new Error('shortUserNameRequired');if(persist){password=value;hash=`$hash:${value}`;}};
-  if(callback) adapter.setPassword=(user,value,options,cb)=>set(user,value,options).then(()=>cb(),cb);
-  else adapter.setPasswordAsync=set;
-  return adapter;
+const {normalizeEosPasswordTarget,setEosUserPasswordWithVerification,verifyEosUserPasswordCredential}=require('../build/lib/eosPassword.js');
+function adapter({canonicalFails=false, optionsFail=false, verify=true}={}){
+ const user={_id:'system.user.user',common:{password:'$old'},native:{}};let accepted='old';const calls=[];
+ const set=async(target,password,options)=>{calls.push({target,password,options});if(canonicalFails&&target==='system.user.user')throw new Error('canonicalRejected');if(optionsFail&&options)throw new Error('optionsRejected');user.common.password=`$${Date.now()}:${password}`;accepted=password};
+ return {calls,getForeignObjectAsync:async id=>id==='system.user.user'?user:null,setPasswordAsync:set,checkPasswordAsync:async(target,password)=>[verify&&['system.user.user','user'].includes(target)&&password===accepted,'system.user.user']};
 }
-
 (async()=>{
-  assert.deepEqual(normalizeEosPasswordTarget('user'),{userId:'system.user.user',userName:'user'});
-  assert.deepEqual(normalizeEosPasswordTarget('system.user.user'),{userId:'system.user.user',userName:'user'});
-  assert.throws(()=>normalizeEosPasswordTarget('system.user.bad.name'),/invalidPasswordTarget/);
-  for(const fixture of [adapterFixture(),adapterFixture({callback:true})]){
-    const result=await setEosUserPasswordWithVerification(fixture,'system.user.user','Strong!2026');
-    assert.equal(result.userName,'user');
-    assert.equal(fixture.calls.find(c=>c.kind==='set').user,'user','password API must receive short user name');
-    assert.deepEqual(fixture.calls.find(c=>c.kind==='set').options,{user:'system.user.admin'});
-    assert.equal(fixture.calls.find(c=>c.kind==='check').user,'user','password check must receive short user name');
-  }
-  const noCheck=adapterFixture();delete noCheck.checkPasswordAsync;
-  await setEosUserPasswordWithVerification(noCheck,'user','NoCheck!2026');
-  await assert.rejects(()=>setEosUserPasswordWithVerification(adapterFixture({persist:false}),'user','Missing!2026'),/passwordNotPersisted/);
-  await assert.rejects(()=>setEosUserPasswordWithVerification(adapterFixture({verify:false}),'user','Verify!2026'),/passwordVerificationFailed/);
-  for(const marker of ['setPasswordAsync(userName','checkPasswordAsync(userName','common?.password','userId.replace(/^system\\.user\\./']) assert(source.includes(marker),`source marker missing: ${marker}`);
-  assert(!/setForeignObject|common\.password\s*=/.test(source),'helper must never hash/write common.password itself');
-  assert(web.includes('extendForeignObjectAsync')&&web.includes('passwordMetadataNotPersisted'),'first-login metadata persistence guard missing');
-  assert(!web.includes('setForeignObjectAsync(access.userId, userObject)'),'stale full-user first-login write remains');
-  console.log('[NexoWatt EOS password write] OK (short name, persistence, credential and native-only metadata)');
-})().catch(error=>{console.error(error?.stack||error);process.exit(1);});
+ assert.deepEqual(normalizeEosPasswordTarget('user'),{userId:'system.user.user',userName:'user'});
+ const normal=adapter();const a=await setEosUserPasswordWithVerification(normal,'system.user.user','Strong!2026');assert.equal(a.apiTarget,'system.user.user');
+ await verifyEosUserPasswordCredential(normal,'system.user.user','Strong!2026');
+ const legacy=adapter({canonicalFails:true});const b=await setEosUserPasswordWithVerification(legacy,'system.user.user','Legacy!2026');assert.equal(b.apiTarget,'user');
+ const noOptions=adapter({optionsFail:true});const c=await setEosUserPasswordWithVerification(noOptions,'system.user.user','NoOptions!2026');assert.ok(['system.user.user','user'].includes(c.apiTarget));assert.ok(noOptions.calls.some(call=>call.options===null));
+ await assert.rejects(()=>setEosUserPasswordWithVerification(adapter({verify:false}),'user','Fail!2026'),/passwordVerificationFailed/);
+ console.log('[NexoWatt EOS password write v7100] OK');
+})().catch(error=>{console.error(error.stack||error);process.exit(1)});

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: 7100 }));
 
   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-v7100.js',
+    'src-admin/public/static/js/nexowatt-stable-v7100.js',
     'adminWww/static/js/nexowatt-stable-login.js',
   ];
   const remove = [
@@ -34,6 +34,8 @@ try {
     'adminWww/js/eos-branding.js',
     'adminWww/css/eos-branding.css',
     'src-admin/public/js/eos-security-ui.js',
+    'adminWww/static/js/nexowatt-stable-v100.js',
+    'src-admin/public/static/js/nexowatt-stable-v99.js',
     'adminWww/static/js/nexowatt-stable-v98.js',
     'src-admin/public/static/js/nexowatt-stable-v97.js',
   ];
@@ -45,7 +47,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, 7100);
   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-v7100-selftest.cjs

@@ -0,0 +1,17 @@
+#!/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=(v,m)=>{if(!v){console.error(`[NexoWatt EOS stable v7100] ${m}`);process.exit(1)}};
+const p=JSON.parse(read('package.json')),io=JSON.parse(read('io-package.json')),info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json')),css=read('adminWww/css/nexowatt-native-shell.css'),stable=read('adminWww/static/js/nexowatt-stable-v7100.js'),login=read('adminWww/static/js/nexowatt-stable-login.js'),boot=read('adminWww/js/eos-role-bootstrap.js'),password=read('src/lib/eosPassword.ts'),web=read('src/lib/web.ts'),index=read('adminWww/index.html'),auto=read('src/lib/eosAutoUpdate.ts');
+must(p.version==='7.10.0'&&io.version==='7.10.0'&&io.common.version==='7.10.0'&&info.version==='7.10.0','version drift');
+must(info.shellCacheVersion===7100&&info.shellCacheTag==='7100','cache tag drift');
+must(index.includes('nexowatt-stable-v7100.js?v=7100')&&index.includes('eos-auto-update.js?v=7100'),'active assets missing');
+must(stable.includes('ensureCockpitScroll')&&stable.includes('disableCockpitScroll')&&stable.includes("overflowY: 'scroll'")&&stable.includes("paper.addEventListener('wheel'")&&stable.includes('var(--nx-content-top, 154px)'),'scroll runtime missing or route cleanup incomplete');
+must(css.includes('restored clean login geometry')&&css.includes('static labels above login fields')&&css.includes('position: static !important')&&css.includes('overflow-y: scroll !important'),'login/scroll CSS missing');
+must(login.includes('MuiInputLabel-shrink')&&login.includes('normalizeGeometry')&&login.includes("removeAttribute('aria-hidden')"),'login static-label runtime missing');
+must(boot.includes("const card = form?.closest?.('.MuiPaper-root')")&&!boot.includes("closest?.('.MuiPaper-root,form,main,section')"),'login Paper ownership incorrect');
+must(boot.includes('waitForPasswordSocket')&&boot.includes('socket.changePassword')&&boot.includes('passwordAlreadyWritten')&&boot.includes('postWithTimeout'),'native user-editor password path missing');
+must(password.includes('apiTarget: normalized.userId')&&password.includes('apiTarget: normalized.userName')&&password.includes('verifyAfterWrite')&&password.includes('verifyEosUserPasswordCredential'),'password compatibility/verification missing');
+must(web.includes('EosPasswordSetupTicket')&&web.includes('passwordAlreadyWritten')&&web.includes('verifyEosUserPasswordCredential'),'setup ticket/finalization path missing');
+must(!/issueEosPasswordSetupTicket[\s\S]{0,600}invalidateEosPasswordSetupTicketsForUser\(userId\)/.test(web),'policy refresh invalidates first-login ticket');
+must(auto.includes('eosNexoWattAutoUpdate !== false')&&auto.includes("const POLICY: NexoWattAutoUpdatePolicy = 'major'"),'NexoWatt stable auto-update default missing');
+console.log('[NexoWatt EOS stable v7100] OK');

package/tools/nexowatt-sync-release-version.cjs

@@ -32,7 +32,10 @@ function syncReleaseVersion(rootDir) {
         throw new Error(`Invalid package.json version: ${version || '<missing>'}`);
     }
 
-    const releaseNo = version.match(/^7\.9\.(\d+)/)?.[1] || version.replace(/[^0-9A-Za-z]+/g, '-');
+    const parsed = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    const releaseNo = parsed
+        ? (parsed[1] === '7' && parsed[2] === '9' ? parsed[3] : `${parsed[1]}${parsed[2]}${parsed[3]}`)
+        : version.replace(/[^0-9A-Za-z]+/g, '-');
     const expectedBase = `https://unpkg.com/iobroker.eos-admin@${version}`;
     const changes = [];
 

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=7100','eos-ems-overview.js?v=7100','nexowatt-stable-v7100.js?v=7100','eos-release-watch.js?v=7100'])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');