iobroker.eos-admin 7.9.95 → 7.9.96

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function readJson(file) {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function writeJson(file, value) {
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function setValue(changes, label, object, key, value) {
+    if (object[key] !== value) {
+        changes.push({ label, previous: object[key], value });
+        object[key] = value;
+    }
+}
+
+function syncReleaseVersion(rootDir) {
+    const root = path.resolve(rootDir);
+    const packageFile = path.join(root, 'package.json');
+    if (!fs.existsSync(packageFile)) {
+        throw new Error(`package.json not found in ${root}`);
+    }
+
+    const pkg = readJson(packageFile);
+    const version = String(pkg.version || '').trim();
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
+        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 expectedBase = `https://unpkg.com/iobroker.eos-admin@${version}`;
+    const changes = [];
+
+    // Keep the human-readable release policy aligned with the package version.
+    if (pkg.nexowattReleasePolicy && typeof pkg.nexowattReleasePolicy === 'object') {
+        const purpose = String(pkg.nexowattReleasePolicy.purpose || '');
+        const nextPurpose = purpose
+            ? purpose.replace(/\b7\.9\.\d+(?:-[0-9A-Za-z.-]+)?\b/g, version)
+            : `accepted NexoWatt EOS release ${version}`;
+        setValue(changes, 'package.json nexowattReleasePolicy.purpose', pkg.nexowattReleasePolicy, 'purpose', nextPurpose);
+        if (version.includes('-')) {
+            setValue(changes, 'package.json nexowattReleasePolicy.acceptedPrerelease', pkg.nexowattReleasePolicy, 'acceptedPrerelease', version);
+        } else if (Object.prototype.hasOwnProperty.call(pkg.nexowattReleasePolicy, 'acceptedPrerelease')) {
+            changes.push({
+                label: 'package.json nexowattReleasePolicy.acceptedPrerelease',
+                previous: pkg.nexowattReleasePolicy.acceptedPrerelease,
+                value: '<removed>',
+            });
+            delete pkg.nexowattReleasePolicy.acceptedPrerelease;
+        }
+    }
+    writeJson(packageFile, pkg);
+
+    const jsonTargets = [
+        {
+            file: 'package-lock.json',
+            update(json) {
+                setValue(changes, 'package-lock.json version', json, 'version', version);
+                if (json.packages?.['']) {
+                    setValue(changes, 'package-lock.json packages[""] version', json.packages[''], 'version', version);
+                }
+            },
+        },
+        {
+            file: 'io-package.json',
+            update(json) {
+                setValue(changes, 'io-package.json top-level version', json, 'version', version);
+                json.common ||= {};
+                setValue(changes, 'io-package.json common.version', json.common, 'version', version);
+                setValue(changes, 'io-package.json common.extIcon', json.common, 'extIcon', `${expectedBase}/admin/admin.svg`);
+                setValue(changes, 'io-package.json common.readme', json.common, 'readme', `${expectedBase}/README.md`);
+                setValue(changes, 'io-package.json common.meta', json.common, 'meta', `${expectedBase}/io-package.json`);
+            },
+        },
+        {
+            file: 'src-admin/package.json',
+            update(json) {
+                setValue(changes, 'src-admin/package.json version', json, 'version', version);
+            },
+        },
+        {
+            file: 'src-admin/package-lock.json',
+            update(json) {
+                setValue(changes, 'src-admin/package-lock.json version', json, 'version', version);
+                if (json.packages?.['']) {
+                    setValue(changes, 'src-admin/package-lock.json packages[""] version', json.packages[''], 'version', version);
+                }
+            },
+        },
+        {
+            file: 'src-admin/src/version.json',
+            update(json) {
+                setValue(changes, 'src-admin/src/version.json version', json, 'version', version);
+            },
+        },
+        {
+            file: 'NEXOWATT_EOS_BUILD_INFO.json',
+            update(json) {
+                setValue(changes, 'NEXOWATT_EOS_BUILD_INFO.json version', json, 'version', version);
+                setValue(changes, 'NEXOWATT_EOS_BUILD_INFO.json label', json, 'label', `v${releaseNo}`);
+                setValue(
+                    changes,
+                    'NEXOWATT_EOS_BUILD_INFO.json repositoryEntry',
+                    json,
+                    'repositoryEntry',
+                    `nexowatt-eos-admin-repository-entry-v${releaseNo}.json`,
+                );
+            },
+        },
+    ];
+
+    for (const target of jsonTargets) {
+        const file = path.join(root, target.file);
+        if (!fs.existsSync(file)) {
+            throw new Error(`${target.file} is missing`);
+        }
+        const json = readJson(file);
+        target.update(json);
+        writeJson(file, json);
+    }
+
+    // Keep one canonical repository entry for the current release. When a new
+    // patch version is merged over an older folder, the entry is created from
+    // the previous canonical entry and then normalized.
+    const buildInfo = readJson(path.join(root, 'NEXOWATT_EOS_BUILD_INFO.json'));
+    const targetEntryName = buildInfo.repositoryEntry;
+    const targetEntryFile = path.join(root, targetEntryName);
+    let entry;
+    if (fs.existsSync(targetEntryFile)) {
+        entry = readJson(targetEntryFile);
+    } else {
+        const candidates = fs
+            .readdirSync(root)
+            .filter(name => /^nexowatt-eos-admin-repository-entry-v.+\.json$/.test(name))
+            .sort((a, b) => fs.statSync(path.join(root, b)).mtimeMs - fs.statSync(path.join(root, a)).mtimeMs);
+        if (!candidates.length) {
+            throw new Error('No repository entry template found');
+        }
+        entry = readJson(path.join(root, candidates[0]));
+        changes.push({ label: targetEntryName, previous: '<missing>', value: 'created' });
+    }
+    entry['eos-admin'] ||= {};
+    setValue(changes, `${targetEntryName} version`, entry['eos-admin'], 'version', version);
+    setValue(changes, `${targetEntryName} meta`, entry['eos-admin'], 'meta', `${expectedBase}/io-package.json`);
+    setValue(changes, `${targetEntryName} icon`, entry['eos-admin'], 'icon', `${expectedBase}/admin/admin.png`);
+    setValue(changes, `${targetEntryName} extIcon`, entry['eos-admin'], 'extIcon', `${expectedBase}/admin/admin.svg`);
+    setValue(changes, `${targetEntryName} readme`, entry['eos-admin'], 'readme', `${expectedBase}/README.md`);
+    writeJson(targetEntryFile, entry);
+
+    return { root, version, changes, repositoryEntry: targetEntryName };
+}
+
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const quiet = args.includes('--quiet');
+    const rootArg = args.find(arg => !arg.startsWith('--'));
+    try {
+        const result = syncReleaseVersion(rootArg || path.resolve(__dirname, '..'));
+        if (!quiet) {
+            if (result.changes.length) {
+                console.log(
+                    `[NexoWatt EOS version sync] repaired ${result.changes.length} release value(s) for ${result.version}: ${result.changes
+                        .map(change => change.label)
+                        .join(', ')}`,
+                );
+            } else {
+                console.log(`[NexoWatt EOS version sync] OK (${result.version}; all release files match)`);
+            }
+        }
+    } catch (error) {
+        console.error(`[NexoWatt EOS version sync] ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+
+module.exports = { syncReleaseVersion };

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

@@ -0,0 +1,16 @@
+#!/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=msg=>{console.error(`[NexoWatt EOS UI overview runtime] ${msg}`);process.exit(1)};
+const runtime=read('adminWww/js/eos-ems-overview.js');const source=read('src-admin/public/js/eos-ems-overview.js');const css=read('adminWww/css/eos-ems-overview.css');const index=read('adminWww/index.html');const role=read('adminWww/js/eos-role-ui.js');const shell=read('adminWww/js/nexowatt-native-shell.js');const intro=read('src-admin/src/tabs/Intro.tsx');const app=read('src-admin/src/App.tsx');const bundle=read('adminWww/assets/index-D2ymscJA-v84.js');
+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','getForeignStates','Keine Kachel besitzt Schreibhoheit','currentDecisions','§14a-Fallback'])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=96','eos-ems-overview.js?v=96','nexowatt-stable-v96.js?v=96'])if(!index.includes(marker))fail(`index marker missing: ${marker}`);
+if(!css.includes('#eos-ems-overview-runtime')||!css.includes('.eos-ems-overview-metrics'))fail('EMS card CSS incomplete');
+if(role.includes("overview.innerHTML = `")||!role.includes('never cover the real Admin Intro'))fail('obsolete role overview still active');
+if(!shell.includes("label: 'Installateur'")||!shell.includes("label: 'Endkunde'"))fail('native hero is not role-aware');
+if(!intro.includes('<NexoWattEmsOverview')||!intro.includes('getOverviewRoleConfig')||!intro.includes('admin ? this.getButtons() : null'))fail('React Intro integration incomplete');
+if(!app.includes('NEXOWATT_EOS_ADMIN_SOCKET = new Connection'))fail('source socket exposure missing');
+if(!bundle.includes('window.NEXOWATT_EOS_ADMIN_SOCKET=new M({'))fail('prebuilt socket exposure missing');
+console.log('[NexoWatt EOS UI overview runtime] OK');

package/tools/nexowatt-validate-package.cjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+const fail = msg => {
+  console.error(`[NexoWatt EOS package validation] ${msg}`);
+  process.exit(1);
+};
+const read = file => fs.readFileSync(path.join(root, file), 'utf8');
+const readJson = file => JSON.parse(read(file));
+const exists = file => fs.existsSync(path.join(root, file));
+
+const pkg = readJson('package.json');
+const pkgLock = readJson('package-lock.json');
+const io = readJson('io-package.json');
+const srcPkg = readJson('src-admin/package.json');
+const srcPkgLock = readJson('src-admin/package-lock.json');
+const srcVersion = readJson('src-admin/src/version.json');
+const buildInfo = readJson('NEXOWATT_EOS_BUILD_INFO.json');
+
+if (pkg.name !== 'iobroker.eos-admin') fail(`package.json name must be iobroker.eos-admin, got ${pkg.name}`);
+if (pkg.private !== false) fail('package.json private must be false for npm publishing');
+
+const prerelease = pkg.version.includes('-');
+if (pkg.publishConfig?.tag !== 'latest') fail(`package must publish through npm latest, got ${pkg.publishConfig?.tag || '<unset>'}`);
+if (!exists('.npmrc') || !/^\s*tag\s*=\s*latest\s*$/m.test(read('.npmrc'))) fail('repository must contain .npmrc with tag=latest');
+if (prerelease) {
+  if (pkg.nexowattReleasePolicy?.distTag !== 'latest') fail('accepted prerelease must record distTag=latest');
+  if (pkg.nexowattReleasePolicy?.acceptedPrerelease !== pkg.version) fail('acceptedPrerelease must match the exact package version');
+} else if (pkg.nexowattReleasePolicy?.acceptedPrerelease) {
+  fail(`stable package must remove stale acceptedPrerelease ${pkg.nexowattReleasePolicy.acceptedPrerelease}`);
+}
+if (pkg.scripts['prepare:eos-release-defaults'] !== 'node tools/nexowatt-ensure-release-defaults.cjs') fail('release-default preparation script is missing');
+if (pkg.scripts['test:eos-release-defaults'] !== 'node tools/nexowatt-release-defaults-selftest.cjs') fail('release-default selftest script is missing');
+if (pkg.scripts['check:eos-publish-channel'] !== 'node tools/nexowatt-publish-channel-guard.cjs') fail('publish channel guard script is missing');
+
+if (pkg.scripts['sync:eos-version'] !== 'node tools/nexowatt-sync-release-version.cjs') fail('sync:eos-version script is missing or incorrect');
+if (pkg.scripts['test:eos-version-sync'] !== 'node tools/nexowatt-version-sync-selftest.cjs') fail('version sync selftest script is missing or incorrect');
+if (pkg.scripts['verify:eos-merge'] !== 'node tools/nexowatt-merge-update-selftest.cjs') fail('merge update selftest script is missing or incorrect');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-version-sync-selftest.cjs')) fail('version sync selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-merge-update-selftest.cjs')) fail('merge update selftest is not part of check:eos-stability');
+if (pkg.scripts['check:eos-stable-v96'] !== 'node tools/nexowatt-stable-v96-selftest.cjs') fail('stable v96 selftest script is missing or incorrect');
+if (!pkg.scripts.prepublishOnly?.startsWith('npm run sync:eos-version && npm run prepare:eos-release-defaults && npm run check:eos-publish-channel')) fail('prepublishOnly must synchronize versions and normalize release defaults before the publish channel guard');
+if (pkg.scripts['precheck:eos-package'] !== 'npm run sync:eos-version && npm run prepare:eos-release-defaults && npm run clean:eos-runtime') fail('precheck:eos-package must synchronize versions, normalize release defaults and clean stale runtime files');
+if (pkg.scripts['precheck:eos-stability'] !== 'npm run sync:eos-version && npm run prepare:eos-release-defaults && npm run clean:eos-runtime') fail('precheck:eos-stability must synchronize versions, normalize release defaults and clean stale runtime files');
+if (pkg.scripts['test:eos-publish-channel'] !== 'node tools/nexowatt-publish-channel-selftest.cjs') fail('publish channel selftest script is missing');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-publish-channel-selftest.cjs')) fail('stability check must execute the publish channel selftest');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-release-defaults-selftest.cjs')) fail('stability check must execute the release-default selftest');
+if (io.native?.auth !== true) fail('fresh sales installations must default to authenticated access');
+if (io.native?.eosHideLegacyBackupFromNonAdmins !== true) fail('internal BackItUp reserve must default to Admin/Service visibility');
+if (io.native?.nexowattHideLegacyBackupFromNonAdmins !== true) fail('NexoWatt backup visibility compatibility flag must default to true');
+for (const [label, value] of [
+  ['io-package common.version', io.common?.version],
+  ['io-package top-level version', io.version],
+  ['package-lock version', pkgLock.version],
+  ['package-lock root version', pkgLock.packages?.['']?.version],
+  ['src-admin package version', srcPkg.version],
+  ['src-admin lock version', srcPkgLock.version],
+  ['src-admin lock root version', srcPkgLock.packages?.['']?.version],
+  ['src-admin source version', srcVersion.version],
+  ['build-info version', buildInfo.version],
+]) if (value !== pkg.version) fail(`${label} must match package.json (${pkg.version}), got ${value}`);
+
+if (io.common?.name !== 'eos-admin') fail(`io-package common.name must be eos-admin, got ${io.common?.name}`);
+if (io.common?.packetName !== 'iobroker.eos-admin') fail(`io-package common.packetName must be iobroker.eos-admin, got ${io.common?.packetName}`);
+if (io.common?.npmPackage !== 'iobroker.eos-admin') fail(`io-package common.npmPackage must be iobroker.eos-admin, got ${io.common?.npmPackage}`);
+if (io.native?.port !== 8081) fail(`EOS Admin default port must be 8081, got ${io.native?.port}`);
+if (io.common?.stopBeforeUpdate !== false) fail('io-package common.stopBeforeUpdate must be false');
+if (io.common?.dontDelete === true || io.common?.nondeletable === true) fail('adapter-level delete flags must not block updates');
+
+const expectedBase = `https://unpkg.com/iobroker.eos-admin@${pkg.version}`;
+for (const [field, expected] of Object.entries({
+  extIcon: `${expectedBase}/admin/admin.svg`,
+  readme: `${expectedBase}/README.md`,
+  meta: `${expectedBase}/io-package.json`,
+})) if (io.common?.[field] !== expected) fail(`io-package common.${field} must be ${expected}, got ${io.common?.[field]}`);
+
+const releaseNo = String(pkg.version).match(/^7\.9\.(\d+)/)?.[1];
+const repositoryEntryFile = buildInfo.repositoryEntry || `nexowatt-eos-admin-repository-entry-v${releaseNo}.json`;
+const repositoryEntry = readJson(repositoryEntryFile)['eos-admin'];
+if (!repositoryEntry) fail(`${repositoryEntryFile} is missing eos-admin`);
+if (repositoryEntry.version !== pkg.version) fail(`repository entry version must be ${pkg.version}, got ${repositoryEntry.version}`);
+for (const [field, expected] of Object.entries({
+  meta: `${expectedBase}/io-package.json`,
+  icon: `${expectedBase}/admin/admin.png`,
+  extIcon: `${expectedBase}/admin/admin.svg`,
+  readme: `${expectedBase}/README.md`,
+})) if (repositoryEntry[field] !== expected) fail(`repository entry ${field} must be ${expected}, got ${repositoryEntry[field]}`);
+
+for (const file of [
+  'adminWww/index.html',
+  'adminWww/js/eos-manual-write-policy.js',
+  'adminWww/js/eos-role-bootstrap.js',
+  'adminWww/js/eos-branding-sanitizer.js',
+  'adminWww/js/eos-policy-client.js',
+  'adminWww/js/nexowatt-native-shell.js',
+  'adminWww/js/eos-native-security.js',
+  'adminWww/js/eos-basic-settings.js',
+  'adminWww/js/eos-role-ui.js',
+  'adminWww/js/eos-account-management.js',
+  'adminWww/js/eos-assistant.js',
+  'adminWww/css/nexowatt-native-shell.css',
+  'adminWww/img/eos/nexowatt-192.png',
+  'src-admin/src/components/NexoWattNavIcon.tsx',
+  'src-admin/src/components/Drawer.tsx',
+  'src-admin/src/components/DrawerItem.tsx',
+  'admin/admin.svg',
+  'LICENSE',
+  'NEXOWATT_PROPRIETARY_LICENSE.md',
+  'THIRD_PARTY_NOTICES.md',
+  'README_STABILITY_V7.9.96.md',
+  'RELEASE_NOTES_V7.9.96.md',
+  'PUBLISH_STABLE_V7.9.96.md',
+  'INSTALL_TEST_V7.9.96.md',
+  'RELEASE_ACCEPTANCE_V7.9.96.md',
+  'MERGE_UPDATE.ps1',
+  'MERGE_UPDATE.cmd',
+  'MERGE_UPDATE_README_V7.9.96.md',
+  'tools/nexowatt-patch-built-frontend.cjs',
+  'tools/nexowatt-native-shell-selftest.cjs',
+  'tools/nexowatt-clean-legacy-runtime.cjs',
+  'tools/nexowatt-runtime-cleanup-selftest.cjs',
+  'tools/nexowatt-esm-syntax-selftest.cjs',
+  'tools/nexowatt-import-integrity-selftest.cjs',
+  'tools/nexowatt-entrypoint-smoke-selftest.cjs',
+  'tools/nexowatt-role-access-selftest.cjs',
+  'tools/nexowatt-first-login-selftest.cjs',
+  'tools/nexowatt-account-management-selftest.cjs',
+  'tools/nexowatt-modern-ui-selftest.cjs',
+  'tools/nexowatt-login-layout-selftest.cjs',
+  'tools/nexowatt-internal-reserve-selftest.cjs',
+  'tools/nexowatt-branding-selftest.cjs',
+  'tools/nexowatt-sync-release-version.cjs',
+  'tools/nexowatt-version-sync-selftest.cjs',
+  'tools/nexowatt-merge-update-selftest.cjs',
+  'tools/nexowatt-stable-v96-selftest.cjs',
+  'tools/nexowatt-ems-overview-selftest.cjs',
+  'tools/nexowatt-ui-overview-runtime-selftest.cjs',
+  'adminWww/js/eos-ems-overview.js',
+  'adminWww/css/eos-ems-overview.css',
+  'adminWww/static/js/nexowatt-stable-v96.js',
+  'src-admin/src/components/Intro/NexoWattEmsOverview.tsx',
+  'tools/nexowatt-publish-channel-guard.cjs',
+  'tools/nexowatt-publish-channel-selftest.cjs',
+  'tools/nexowatt-ensure-release-defaults.cjs',
+  'tools/nexowatt-release-defaults-selftest.cjs',
+  'tools/nexowatt-default-port-selftest.cjs',
+  '.npmrc',
+  repositoryEntryFile,
+]) if (!exists(file)) fail(`missing required file: ${file}`);
+
+for (const file of pkg.files || []) {
+  const normalized = String(file).replace(/\\/g, '/').replace(/\/\*\*\/\*$/, '');
+  if (!/[?*]/.test(normalized) && !exists(normalized.replace(/\/$/, ''))) fail(`package.json files entry does not exist: ${file}`);
+}
+
+const index = read('adminWww/index.html');
+const refs = [...index.matchAll(/(?:src|href)="\.\/([^"?#]+)(?:\?[^"#]*)?"/g)].map(m => m[1]);
+const missing = refs.filter(ref => !exists(path.join('adminWww', ref)));
+if (missing.length) fail(`adminWww/index.html references missing files:\n${missing.join('\n')}`);
+
+const runtime = buildInfo.runtimeEntry;
+const runtimeNumber = Number(String(runtime).replace(/^v/, ''));
+const shellCache = Number(buildInfo.shellCacheVersion ?? buildInfo.nativeShellVersion ?? runtimeNumber);
+const shellTag = String(buildInfo.shellCacheTag || shellCache);
+if (!runtime || !Number.isFinite(runtimeNumber)) fail(`invalid runtimeEntry ${runtime}`);
+if (!Number.isFinite(shellCache)) fail(`invalid shellCacheVersion ${buildInfo.shellCacheVersion}`);
+for (const marker of [
+  `hostInit-${runtime}.js?v=${runtimeNumber}`,
+  `index-CQZugZ1z-${runtime}.js?v=${runtimeNumber}`,
+  `eos-manual-write-policy.js?v=${shellTag}`,
+  `nexowatt-native-shell.css?v=${shellTag}`,
+  `nexowatt-native-shell.js?v=${shellTag}`,
+  `eos-native-security.js?v=${shellTag}`,
+]) if (!index.includes(marker)) fail(`adminWww/index.html missing ${marker}`);
+
+if (!index.includes(`eos-role-bootstrap.js?v=${shellTag}`)) fail('role bootstrap cache key mismatch');
+if (!index.includes(`eos-branding-sanitizer.js?v=${shellTag}`)) fail('branding sanitizer cache key mismatch');
+if (!index.includes(`eos-role-ui.js?v=${shellTag}`)) fail('role UI cache key mismatch');
+if (!index.includes(`eos-account-management.js?v=${shellTag}`)) fail('account management cache key mismatch');
+if (!index.includes(`eos-assistant.js?v=${shellTag}`)) fail('EOS Assist cache key mismatch');
+if (!index.includes(`eos-ems-overview.js?v=${shellTag}`)) fail('EMS overview cache key mismatch');
+if (!index.includes(`eos-ems-overview.css?v=${shellTag}`)) fail('EMS overview CSS cache key mismatch');
+if (!index.includes(`nexowatt-stable-v96.js?v=${shellTag}`)) fail('stable v96 cache key mismatch');
+if (index.indexOf(`eos-manual-write-policy.js?v=${shellTag}`) > index.indexOf(`hostInit-${runtime}.js?v=${runtimeNumber}`)) fail('manual-write policy must load before the React runtime');
+if (!index.includes('class="eos-native-shell"')) fail('native NexoWatt shell class missing');
+for (const legacy of ['eos-branding.js', 'eos-security-ui.js', 'eos-console-quiet.js', 'eos-objects-state-tools.js']) {
+  if (index.includes(legacy)) fail(`legacy browser overlay still loaded: ${legacy}`);
+}
+
+const activeBootstrapFile = `adminWww/assets/bootstrap-COulQZax-${runtime}.js`;
+for (const file of [
+  `adminWww/assets/hostInit-${runtime}.js`,
+  `adminWww/assets/index-CQZugZ1z-${runtime}.js`,
+  activeBootstrapFile,
+  `adminWww/assets/Objects-DPan0bzw-${runtime}.js`,
+  `adminWww/assets/index-D2ymscJA-${runtime}.js`,
+  `adminWww/remoteEntry-${runtime}.js`,
+]) if (!exists(file)) fail(`missing active runtime file ${file}`);
+
+const bootstrap = read(activeBootstrapFile);
+if (!bootstrap.includes('window.adapterName="eos-admin"')) fail('frontend bootstrap does not set window.adapterName="eos-admin"');
+if (bootstrap.includes('window.adapterName="admin"')) fail('frontend bootstrap still contains window.adapterName="admin"');
+for (const marker of ['NEXOWATT_TAB_ICON', 'nexowatt-native-nav-item', 'nexowatt-native-nav-icon', 'tabName:h.name', 'NexoWatt EOS', 'Zugänge & Rechte']) {
+  if (!bootstrap.includes(marker)) fail(`active bootstrap missing native navigation marker ${marker}`);
+}
+
+const drawer = read('src-admin/src/components/Drawer.tsx');
+const drawerItem = read('src-admin/src/components/DrawerItem.tsx');
+const navIcon = read('src-admin/src/components/NexoWattNavIcon.tsx');
+for (const marker of ['getNexoWattTabTitle', 'getNexoWattTabIcon', "'tab-intro': 'Übersicht'", "'tab-users': 'Zugänge & Rechte'", 'System-Notfallsicherung', 'NexoWatt Sicherung']) {
+  if (!drawer.includes(marker)) fail(`Drawer source missing ${marker}`);
+}
+if (!drawerItem.includes('className="nexowatt-native-nav-item"') || !drawerItem.includes('data-eos-tab={tabName}')) fail('DrawerItem is not native-shell aware');
+if (!navIcon.includes('eos-native-nav-icon-source') || !navIcon.includes('nexowatt-native-nav-icon')) fail('native SVG navigation icon component is incomplete');
+
+const shell = read('adminWww/js/nexowatt-native-shell.js');
+const shellCss = read('adminWww/css/nexowatt-native-shell.css');
+const nativeSecurity = read('adminWww/js/eos-native-security.js');
+const accountManagement = read('adminWww/js/eos-account-management.js');
+if (!shell.includes(`const VERSION = 'v${shellCache}-nexowatt-native-shell`)) fail(`native shell version marker v${shellCache} missing`);
+if (!shell.includes('Navigation labels and') || !shell.includes('rendered natively by Drawer.tsx')) fail('native shell ownership guard missing');
+if (shell.includes('innerHTML = cfg.svg') || shell.includes('textNode.textContent = cfg.label')) fail('native shell still rewrites navigation icons or labels after render');
+if (!shell.includes('NEXOWATT_EOS_DOM_COORDINATOR')) fail('native shell does not use the shared DOM coordinator');
+if (!shellCss.includes('.nexowatt-native-nav-item') || !shellCss.includes('.eos-native-nav-icon') || !shellCss.includes('.nexowatt-native-nav-icon')) fail('native shell CSS lacks React navigation selectors');
+if (!nativeSecurity.includes('shouldBlockInstanceDelete')) fail('minimal native security API missing instance protection');
+if (/addEventListener\(['"]click['"]/.test(nativeSecurity)) fail('native security must not globally intercept clicks');
+if (!accountManagement.includes('NEXOWATT_EOS_ACCOUNT_MANAGEMENT') || !accountManagement.includes('X-NexoWatt-EOS-Account-Reset') || !accountManagement.includes('ensureEntrySurface')) fail('account-management runtime is incomplete');
+if (accountManagement.includes("launcher.className = 'eos-account-management-launcher'")) fail('account management must not create a separate launcher');
+if (accountManagement.includes('new MutationObserver')) fail('account-management runtime adds a second broad DOM observer');
+if (read('src-admin/public/js/eos-account-management.js') !== accountManagement) fail('account-management source/build drift');
+const roleBootstrap = read('adminWww/js/eos-role-bootstrap.js');
+if (!roleBootstrap.includes('installIntegratedFirstLogin') || !roleBootstrap.includes('v96 compact normal-login first activation')) fail('compact integrated first-login is incomplete');
+if (/data-eos-account=|selector\.innerHTML/.test(roleBootstrap)) fail('login role buttons must not enlarge the normal login card');
+if (!roleBootstrap.includes('nexowatt/account/passwordless-status') || !roleBootstrap.includes('eligibility.allowed')) fail('server-checked first-login eligibility is incomplete');
+if (roleBootstrap.includes('installPasswordlessFirstLoginLauncher')) fail('old first-login launcher remains active');
+const assistant = read('adminWww/js/eos-assistant.js');
+if (!assistant.includes('NEXOWATT_EOS_ASSIST_DISABLED')) fail('EOS Assist must be disabled in stable');
+
+const mf = read('adminWww/mf-manifest.json');
+if (!mf.includes(`remoteEntry-${runtime}.js`) || !mf.includes(`index-D2ymscJA-${runtime}.js`)) fail('module federation manifest is not on the active runtime');
+
+const webBuild = read('build/lib/web.js');
+if (!webBuild.includes('refreshLifetime: 60 * 60 * 24 * 7')) fail('build/lib/web.js must keep upstream-compatible refresh lifetime');
+if (!webBuild.includes('Follow upstream admin semantics again')) fail('build/lib/web.js lacks session compatibility fix');
+const mainBuild = read('build/main.js');
+if (!mainBuild.includes('v37 BackItUp/runtime-adapter compatibility')) fail('build/main.js lacks BackItUp compatibility guard');
+
+if (!pkg.scripts['nexowatt:patch-built-frontend']) fail('missing nexowatt:patch-built-frontend script');
+if (pkg.scripts['check:eos-esm'] !== 'node tools/nexowatt-esm-syntax-selftest.cjs') fail('check:eos-esm script is missing or incorrect');
+if (pkg.scripts['check:eos-imports'] !== 'node tools/nexowatt-import-integrity-selftest.cjs') fail('check:eos-imports script is missing or incorrect');
+if (pkg.scripts['check:eos-entry'] !== 'node tools/nexowatt-entrypoint-smoke-selftest.cjs') fail('check:eos-entry script is missing or incorrect');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-esm-syntax-selftest.cjs')) fail('ESM syntax selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-import-integrity-selftest.cjs')) fail('import integrity selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-entrypoint-smoke-selftest.cjs')) fail('entrypoint smoke selftest is not part of check:eos-stability');
+if (pkg.scripts['clean:eos-runtime'] !== 'node tools/nexowatt-clean-legacy-runtime.cjs') fail('clean:eos-runtime script is missing or incorrect');
+if (pkg.scripts.prepack !== 'node tools/nexowatt-sync-release-version.cjs --quiet && node tools/nexowatt-clean-legacy-runtime.cjs --quiet') fail('prepack must silently synchronize versions and clean stale runtime files');
+if (!pkg.scripts.build?.includes('npm run clean:eos-runtime')) fail('build must finish with runtime cleanup');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-role-access-selftest.cjs')) fail('role access selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-first-login-selftest.cjs')) fail('first-login selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-account-management-selftest.cjs')) fail('account-management selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-modern-ui-selftest.cjs')) fail('modern-UI selftest is not part of check:eos-stability');
+if (pkg.scripts['test:eos-login-layout'] !== 'node tools/nexowatt-login-layout-selftest.cjs') fail('login-layout selftest script is missing or incorrect');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-login-layout-selftest.cjs')) fail('login-layout selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-internal-reserve-selftest.cjs')) fail('internal reserve selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-branding-selftest.cjs')) fail('branding selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-native-shell-selftest.cjs')) fail('native shell selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-assistant-separation-selftest.cjs')) fail('assistant separation selftest is not part of check:eos-stability');
+if (!exists('adminWww/img/eos/nexowatt-eos-brand-wide.png')) fail('new NexoWatt EOS brand logo asset missing');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-runtime-cleanup-selftest.cjs')) fail('runtime cleanup selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-ems-overview-selftest.cjs')) fail('EMS React overview selftest is not part of check:eos-stability');
+if (!pkg.scripts['check:eos-stability']?.includes('nexowatt-ui-overview-runtime-selftest.cjs')) fail('EMS runtime selftest is not part of check:eos-stability');
+if (!read('tasks.mts').includes('patchNexoWattBuiltFrontend')) fail('tasks.mts does not execute the EOS post-build frontend patch');
+
+console.log('[NexoWatt EOS package validation] OK');

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

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { syncReleaseVersion } = require('./nexowatt-sync-release-version.cjs');
+
+const root = path.resolve(__dirname, '..');
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'nexowatt-eos-version-sync-'));
+const fail = message => {
+    console.error(`[NexoWatt EOS version sync selftest] ${message}`);
+    fs.rmSync(temp, { recursive: true, force: true });
+    process.exit(1);
+};
+const readJson = file => JSON.parse(fs.readFileSync(path.join(temp, file), 'utf8'));
+const writeJson = (file, value) => {
+    const target = path.join(temp, file);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+};
+
+try {
+    const currentPkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const version = currentPkg.version;
+    writeJson('package.json', currentPkg);
+    writeJson('package-lock.json', { name: currentPkg.name, version: '7.9.92', packages: { '': { version: '7.9.92' } } });
+    writeJson('io-package.json', {
+        version: '7.9.92',
+        common: {
+            version: '7.9.92',
+            extIcon: 'https://unpkg.com/iobroker.eos-admin@7.9.92/admin/admin.svg',
+            readme: 'https://unpkg.com/iobroker.eos-admin@7.9.92/README.md',
+            meta: 'https://unpkg.com/iobroker.eos-admin@7.9.92/io-package.json',
+        },
+        native: {},
+    });
+    writeJson('src-admin/package.json', { name: 'src-rx', version: '7.9.92' });
+    writeJson('src-admin/package-lock.json', { name: 'src-rx', version: '7.9.92', packages: { '': { version: '7.9.92' } } });
+    writeJson('src-admin/src/version.json', { version: '7.9.92' });
+    writeJson('NEXOWATT_EOS_BUILD_INFO.json', { version: '7.9.92', label: 'v92', repositoryEntry: 'nexowatt-eos-admin-repository-entry-v92.json' });
+    writeJson('nexowatt-eos-admin-repository-entry-v92.json', {
+        'eos-admin': {
+            version: '7.9.92',
+            meta: 'https://unpkg.com/iobroker.eos-admin@7.9.92/io-package.json',
+            icon: 'https://unpkg.com/iobroker.eos-admin@7.9.92/admin/admin.png',
+            extIcon: 'https://unpkg.com/iobroker.eos-admin@7.9.92/admin/admin.svg',
+            readme: 'https://unpkg.com/iobroker.eos-admin@7.9.92/README.md',
+        },
+    });
+
+    const result = syncReleaseVersion(temp);
+    if (result.version !== version) fail(`expected ${version}, got ${result.version}`);
+
+    const io = readJson('io-package.json');
+    const lock = readJson('package-lock.json');
+    const src = readJson('src-admin/package.json');
+    const srcLock = readJson('src-admin/package-lock.json');
+    const srcVersion = readJson('src-admin/src/version.json');
+    const build = readJson('NEXOWATT_EOS_BUILD_INFO.json');
+    const entry = readJson(build.repositoryEntry)['eos-admin'];
+    const expectedBase = `https://unpkg.com/iobroker.eos-admin@${version}`;
+
+    for (const [label, actual] of [
+        ['io top-level', io.version],
+        ['io common', io.common.version],
+        ['lock', lock.version],
+        ['lock root', lock.packages[''].version],
+        ['src package', src.version],
+        ['src lock', srcLock.version],
+        ['src lock root', srcLock.packages[''].version],
+        ['src version', srcVersion.version],
+        ['build version', build.version],
+        ['entry version', entry.version],
+    ]) {
+        if (actual !== version) fail(`${label} was not synchronized: ${actual}`);
+    }
+    if (io.common.meta !== `${expectedBase}/io-package.json`) fail('io-package URL was not synchronized');
+    if (entry.meta !== `${expectedBase}/io-package.json`) fail('repository entry URL was not synchronized');
+    if (!fs.existsSync(path.join(temp, build.repositoryEntry))) fail('current repository entry was not created');
+
+    fs.rmSync(temp, { recursive: true, force: true });
+    console.log(`[NexoWatt EOS version sync selftest] OK (${version}; stale 7.9.92 merge repaired)`);
+} catch (error) {
+    fail(error instanceof Error ? error.stack || error.message : String(error));
+}

package/INSTALL_TEST_V7.9.95.md

@@ -1,15 +0,0 @@
-# Installationstest 7.9.95
-
-```bash
-cd /opt/iobroker
-iobroker stop eos-admin.0
-npm install --no-save --omit=dev iobroker.eos-admin@7.9.95
-iobroker upload eos-admin
-iobroker restart eos-admin.0
-```
-
-Version prüfen:
-
-```bash
-node -p "require('/opt/iobroker/node_modules/iobroker.eos-admin/package.json').version"
-```

package/NEXOWATT_EOS_STABLE_7.9.94.md

@@ -1,16 +0,0 @@
-# NexoWatt EOS Admin 7.9.94 – Stable candidate
-
-## Stable scope
-
-- Standard port 8081 and authentication enabled.
-- Initial commissioning credentials for `installer`, `guest`, and `user`: password `nexowatt`.
-- A personal password is mandatory immediately after the first successful login.
-- The old passwordless activation flow is disabled.
-- Admin/Service credentials are never changed by the bootstrap.
-- EOS Assist is disabled in this stable release and will return only after its separate read-only redesign and acceptance.
-- The login card remains fully usable when validation or authentication errors are shown.
-- Customer-visible publisher: NexoWatt; technical npm identity remains `iobroker.eos-admin` for update compatibility.
-
-## Security note
-
-The shared commissioning password is only an initial credential. Commissioning is not complete until installer and customer accounts have replaced it with personal passwords. Shipping a system with the initial credential still active is not permitted.

package/PUBLISH_STABLE_V7.9.95.md

@@ -1,16 +0,0 @@
-# npm-Veröffentlichung 7.9.95
-
-Nach dem Entpacken der Merge-ZIP zuerst `MERGE_UPDATE.cmd` ausführen. Danach:
-
-```powershell
-npm login
-npm whoami
-npm publish --dry-run --tag latest
-npm publish --tag latest
-```
-
-Kontrolle:
-
-```powershell
-npm view iobroker.eos-admin@latest version
-```

package/README_STABILITY_V7.9.95.md

@@ -1,12 +0,0 @@
-# NexoWatt EOS Admin 7.9.95 – Stabilität
-
-Version 7.9.95 ist ein packaging-only Stable-Update. Die produktive Laufzeit, Rollenlogik, Erstanmeldung mit dem Startpasswort `nexowatt`, Standardport 8081 und die Deaktivierung des EOS Assist bleiben gegenüber 7.9.94 unverändert.
-
-Neu ist die mergesichere Release-Vorbereitung: Alle versionsführenden Dateien werden vor Prüfung, Packen und npm-Veröffentlichung automatisch an `package.json` angeglichen.
-
-Die npm-Dateiliste wird nun zusätzlich gegen das reale Dateisystem geprüft. Nicht vorhandene oder nicht gepackte Pflichtdateien brechen die Veröffentlichung vor dem Upload ab.
-
-
-Zusätzlich werden die Rootmetadaten der Lockdateien gegen die zugehörigen `package.json`-Dateien geprüft. Dadurch können veraltete `prepublishOnly`-, `prepack`- oder Stabilitätsskripte nicht mehr unbemerkt in einer gemischten Arbeitskopie verbleiben.
-
-Die Merge-Datei für bestehende Arbeitsordner wird ohne übergeordneten Versionsordner erzeugt. `package.json`, `io-package.json` und `MERGE_UPDATE.cmd` liegen unmittelbar auf der ersten ZIP-Ebene.