iobroker.eos-admin 7.10.0 → 7.10.2

package/build/lib/nexowattStableAuth.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startNexowattStableAuth = startNexowattStableAuth;
-const START_PASSWORD = 'nexowatt';
-const MARKER_KEYS = ["eosFirstLoginPending", "eosMustChangePassword", "eosPasswordSetupRequired", "firstLoginRequired", "mustChangePassword", "nexowattFirstLoginPending", "nexowattMustChangePassword", "nexowattPasswordSetupRequired", "passwordChangeRequired"];
-const timers = new WeakMap();
-function pendingByNative(native) {
-    if (!native || typeof native !== 'object') return false;
-    return MARKER_KEYS.some(key => native[key] === true || native[key] === 'pending' || native[key] === 'required' || native[key] === 'starter');
-}
-async function setPassword(adapter, user, password) {
-    if (typeof adapter.setPasswordAsync === 'function') return adapter.setPasswordAsync(user, password, { user: 'system.user.admin' });
-    return new Promise((resolve, reject) => adapter.setPassword(user, password, { user: 'system.user.admin' }, err => err ? reject(err) : resolve()));
-}
-async function ensureGroupMembership(adapter, userId, groupId) {
-    const group = await adapter.getForeignObjectAsync(groupId);
-    if (!group || group.type !== 'group') return;
-    group.common = group.common || { name: groupId.split('.').pop(), members: [] };
-    group.common.members = Array.isArray(group.common.members) ? group.common.members : [];
-    if (!group.common.members.includes(userId)) {
-        group.common.members.push(userId);
-        await adapter.setForeignObjectAsync(groupId, group, { user: 'system.user.admin' });
-    }
-}
-async function createUser(adapter, name) {
-    const id = `system.user.${name}`;
-    await adapter.setForeignObjectAsync(id, {
-        _id: id, type: 'user',
-        common: { name, enabled: true, password: '' },
-        native: { nexowattManagedAccount: true, nexowattMustChangePassword: true, nexowattPasswordState: 'starter' }
-    }, { user: 'system.user.admin' });
-    return adapter.getForeignObjectAsync(id);
-}
-async function prepareOne(adapter, name, group, createMissing) {
-    const id = `system.user.${name}`;
-    let obj = await adapter.getForeignObjectAsync(id);
-    let created = false;
-    if (!obj && createMissing) { obj = await createUser(adapter, name); created = true; }
-    if (!obj || obj.type !== 'user') return;
-    obj.native = obj.native || {};
-    const empty = !obj.common || !obj.common.password;
-    const pending = created || empty || pendingByNative(obj.native) || obj.native.nexowattPasswordState === 'starter';
-    if (pending) {
-        await setPassword(adapter, name, START_PASSWORD);
-        obj = await adapter.getForeignObjectAsync(id) || obj;
-        obj.native = obj.native || {};
-        obj.native.nexowattManagedAccount = true;
-        obj.native.nexowattStarterPasswordActive = true;
-        obj.native.nexowattMustChangePassword = true;
-        obj.native.nexowattPasswordState = 'starter';
-        obj.native.nexowattStarterPasswordUpdatedAt = new Date().toISOString();
-        for (const key of MARKER_KEYS) {
-            if (/required|must|pending|first/i.test(key)) obj.native[key] = true;
-        }
-        await adapter.setForeignObjectAsync(id, obj, { user: 'system.user.admin' });
-    }
-    await ensureGroupMembership(adapter, id, group);
-}
-async function reconcile(adapter) {
-    try {
-        await prepareOne(adapter, 'installer', 'system.group.installer', true);
-        const guest = await adapter.getForeignObjectAsync('system.user.guest');
-        const user = await adapter.getForeignObjectAsync('system.user.user');
-        if (guest || !user) await prepareOne(adapter, 'guest', 'system.group.endkunden', true);
-        if (user) await prepareOne(adapter, 'user', 'system.group.endkunden', false);
-    } catch (e) { adapter.log.warn(`[NexoWatt EOS login] Starter-account reconciliation failed: ${e && e.message || e}`); }
-}
-function startNexowattStableAuth(adapter) {
-    if (timers.has(adapter)) return;
-    void reconcile(adapter);
-    const timer = setInterval(() => void reconcile(adapter), 5000);
-    if (timer.unref) timer.unref();
-    timers.set(adapter, timer);
-}

package/src/lib/eosAutoUpdate.ts

@@ -1,320 +0,0 @@
-/**
- * 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-cache-update-selftest.cjs

@@ -1,12 +0,0 @@
-#!/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 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'),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 = '${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-request-security-selftest.cjs

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const assert=require('node:assert/strict');
-const {isEosSameOriginRequest}=require('../build/lib/eosRequestSecurity.js');
-assert.equal(isEosSameOriginRequest({host:'192.168.10.124:8081'}),true);
-assert.equal(isEosSameOriginRequest({origin:'http://192.168.10.124:8081',host:'192.168.10.124:8081','sec-fetch-site':'same-origin'}),true);
-assert.equal(isEosSameOriginRequest({origin:'https://eos.example.test',host:'proxy:443','x-forwarded-host':'eos.example.test','sec-fetch-site':'same-site'}),true);
-assert.equal(isEosSameOriginRequest({origin:'http://192.168.10.125:8081',host:'192.168.10.124:8081','sec-fetch-site':'same-origin'}),false);
-assert.equal(isEosSameOriginRequest({origin:'http://192.168.10.124:8081',host:'192.168.10.124:8081','sec-fetch-site':'cross-site'}),false);
-assert.equal(isEosSameOriginRequest({origin:'file:///tmp/eos',host:'192.168.10.124:8081'}),false);
-console.log('[NexoWatt EOS request security] OK (LAN, proxy and cross-site guard)');

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

@@ -1,17 +0,0 @@
-#!/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');