iobroker.eos-admin 7.10.0 → 7.10.2

package/tools/nexowatt-prebuilt-release-selftest.cjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const root = path.resolve(__dirname, '..');
+const manifestFile = path.join(root, 'NEXOWATT_EOS_PREBUILT_MANIFEST.json');
+const packageFile = path.join(root, 'package.json');
+const trackedRoots = [
+    'src',
+    'build',
+    'src-admin/src',
+    'src-admin/public',
+    'adminWww',
+    'admin',
+    'public',
+    'tools',
+];
+const trackedFiles = [
+    'tasks.mts',
+    'tsconfig.json',
+    'tsconfig.build.json',
+];
+const expectedPrepublishOnly =
+    'npm run sync:eos-version && npm run prepare:eos-release-defaults && npm run clean:eos-runtime && npm run check:eos-publish-channel && npm run check:eos-package && npm run check:eos-stability';
+const expectedPrepack =
+    'node tools/nexowatt-sync-release-version.cjs --quiet && node tools/nexowatt-ensure-release-defaults.cjs && node tools/nexowatt-clean-legacy-runtime.cjs --quiet && node tools/nexowatt-prebuilt-release-selftest.cjs';
+
+function normalize(relative) {
+    return relative.replace(/\\/g, '/');
+}
+
+function walk(relative, output) {
+    const absolute = path.join(root, relative);
+    if (!fs.existsSync(absolute)) return;
+    const stat = fs.lstatSync(absolute);
+    if (stat.isSymbolicLink()) {
+        throw new Error(`symbolic links are not allowed in the sealed release: ${normalize(relative)}`);
+    }
+    if (stat.isFile()) {
+        output.push(normalize(relative));
+        return;
+    }
+    if (!stat.isDirectory()) return;
+    for (const name of fs.readdirSync(absolute).sort()) {
+        walk(path.join(relative, name), output);
+    }
+}
+
+function collectTrackedFiles() {
+    const files = [];
+    for (const relative of trackedRoots) walk(relative, files);
+    for (const relative of trackedFiles) {
+        const absolute = path.join(root, relative);
+        if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+            throw new Error(`tracked release input is missing: ${relative}`);
+        }
+        files.push(normalize(relative));
+    }
+    return [...new Set(files)].sort();
+}
+
+function sha256(relative) {
+    return crypto.createHash('sha256').update(fs.readFileSync(path.join(root, relative))).digest('hex');
+}
+
+function createManifest() {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    const files = collectTrackedFiles();
+    const hashes = {};
+    for (const relative of files) hashes[relative] = sha256(relative);
+    return {
+        format: 1,
+        package: pkg.name,
+        version: pkg.version,
+        algorithm: 'sha256',
+        fileCount: files.length,
+        trackedRoots,
+        trackedFiles,
+        files: hashes,
+    };
+}
+
+function writeManifest() {
+    const manifest = createManifest();
+    fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    console.log(`[NexoWatt EOS prebuilt release] sealed ${manifest.fileCount} source/runtime file(s) for ${manifest.version}`);
+}
+
+function resolveLocal(fromFile, specifier) {
+    const base = path.resolve(path.dirname(fromFile), specifier);
+    const candidates = [base, `${base}.js`, `${base}.json`, path.join(base, 'index.js')];
+    if (fs.existsSync(base) && fs.statSync(base).isDirectory()) {
+        const nestedPackage = path.join(base, 'package.json');
+        if (fs.existsSync(nestedPackage)) {
+            try {
+                const value = JSON.parse(fs.readFileSync(nestedPackage, 'utf8'));
+                if (value.main) candidates.unshift(path.resolve(base, value.main));
+            } catch {
+                // The normal package validator reports malformed JSON in detail.
+            }
+        }
+    }
+    return candidates.find(candidate => fs.existsSync(candidate) && fs.statSync(candidate).isFile()) || null;
+}
+
+function inspectRuntimeClosure(failures) {
+    const entry = path.join(root, 'build', 'main.js');
+    const visited = new Set();
+    const runtimeFiles = new Set();
+
+    function inspect(file) {
+        const absolute = path.resolve(file);
+        if (visited.has(absolute)) return;
+        visited.add(absolute);
+        runtimeFiles.add(absolute);
+        if (!fs.existsSync(absolute)) {
+            failures.push(`missing runtime file ${normalize(path.relative(root, absolute))}`);
+            return;
+        }
+        if (!absolute.endsWith('.js')) return;
+
+        const parsed = spawnSync(process.execPath, ['--check', absolute], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (parsed.status !== 0) {
+            failures.push(
+                `${normalize(path.relative(root, absolute))} does not parse: ${(parsed.stderr || parsed.stdout || '').trim()}`,
+            );
+        }
+
+        const text = fs.readFileSync(absolute, 'utf8');
+        const patterns = [
+            /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
+            /\brequire\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g,
+            /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g,
+        ];
+        for (const pattern of patterns) {
+            pattern.lastIndex = 0;
+            let match;
+            while ((match = pattern.exec(text))) {
+                const specifier = match[1];
+                if (!specifier.startsWith('.')) continue;
+                const target = resolveLocal(absolute, specifier);
+                if (!target) {
+                    failures.push(`${normalize(path.relative(root, absolute))} -> ${specifier} cannot be resolved`);
+                    continue;
+                }
+                inspect(target);
+            }
+        }
+    }
+
+    inspect(entry);
+    for (const required of [
+        'build/main.js',
+        'build/lib/web.js',
+        'build/lib/eosAutoUpdate.js',
+        'build/lib/eosRequestSecurity.js',
+    ]) {
+        if (!runtimeFiles.has(path.join(root, required))) {
+            failures.push(`entrypoint closure does not include required module ${required}`);
+        }
+    }
+    return runtimeFiles.size;
+}
+
+function verifyManifest(failures) {
+    if (!fs.existsSync(manifestFile)) {
+        failures.push('NEXOWATT_EOS_PREBUILT_MANIFEST.json is missing');
+        return 0;
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    } catch (error) {
+        failures.push(`prebuilt manifest is invalid JSON: ${error.message}`);
+        return 0;
+    }
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    if (manifest.format !== 1) failures.push(`unsupported prebuilt manifest format ${manifest.format}`);
+    if (manifest.package !== pkg.name) failures.push(`prebuilt manifest package ${manifest.package} does not match ${pkg.name}`);
+    if (manifest.version !== pkg.version) failures.push(`prebuilt manifest version ${manifest.version} does not match ${pkg.version}`);
+    if (manifest.algorithm !== 'sha256') failures.push(`prebuilt manifest algorithm must be sha256, got ${manifest.algorithm}`);
+
+    let currentFiles = [];
+    try {
+        currentFiles = collectTrackedFiles();
+    } catch (error) {
+        failures.push(error.message);
+        return 0;
+    }
+    const sealedFiles = Object.keys(manifest.files || {}).sort();
+    const currentSet = new Set(currentFiles);
+    const sealedSet = new Set(sealedFiles);
+    for (const relative of currentFiles) {
+        if (!sealedSet.has(relative)) failures.push(`unsealed release file: ${relative}`);
+    }
+    for (const relative of sealedFiles) {
+        if (!currentSet.has(relative)) failures.push(`sealed release file is missing: ${relative}`);
+    }
+    for (const relative of sealedFiles) {
+        if (!currentSet.has(relative)) continue;
+        const actual = sha256(relative);
+        if (actual !== manifest.files[relative]) failures.push(`sealed release file changed after validation: ${relative}`);
+    }
+    if (manifest.fileCount !== sealedFiles.length) {
+        failures.push(`prebuilt manifest fileCount ${manifest.fileCount} does not match ${sealedFiles.length}`);
+    }
+    return sealedFiles.length;
+}
+
+function verifyLifecycle(failures) {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    const scripts = pkg.scripts || {};
+    if (scripts.prepublishOnly !== expectedPrepublishOnly) {
+        failures.push('prepublishOnly is not the canonical dependency-free direct-publish workflow');
+    }
+    if (scripts.prepack !== expectedPrepack) {
+        failures.push('prepack is not the canonical dependency-free prebuilt-artifact verifier');
+    }
+    if (scripts['check:eos-prebuilt-release'] !== 'node tools/nexowatt-prebuilt-release-selftest.cjs') {
+        failures.push('check:eos-prebuilt-release script is missing or incorrect');
+    }
+    if (scripts['seal:eos-prebuilt-release'] !== 'node tools/nexowatt-prebuilt-release-selftest.cjs --write') {
+        failures.push('seal:eos-prebuilt-release script is missing or incorrect');
+    }
+    for (const [name, command] of [
+        ['prepublishOnly', scripts.prepublishOnly || ''],
+        ['prepack', scripts.prepack || ''],
+    ]) {
+        for (const forbidden of [
+            /(?:^|\s)tsc(?:\s|$)/i,
+            /(?:^|\s)tsx(?:\s|$)/i,
+            /build:backend/i,
+            /build:frontend/i,
+            /(?:^|\s)npx(?:\s|$)/i,
+            /npm\s+(?:i|install|ci)(?:\s|$)/i,
+        ]) {
+            if (forbidden.test(command)) failures.push(`${name} must not require local development dependencies: ${command}`);
+        }
+    }
+    const backendRuntimeSelftestFile = path.join(root, 'tools', 'nexowatt-backend-runtime-selftest.cjs');
+    if (!fs.existsSync(backendRuntimeSelftestFile)) {
+        failures.push('tools/nexowatt-backend-runtime-selftest.cjs is missing');
+    } else {
+        const backendRuntimeSelftest = fs.readFileSync(backendRuntimeSelftestFile, 'utf8');
+        if (!backendRuntimeSelftest.includes('dependency-free on Windows')) {
+            failures.push('backend runtime selftest is missing the cross-platform publish marker');
+        }
+        if (/const\s+npm\s*=\s*process\.platform|spawnSync\(\s*npm\s*,|['"]npm\.cmd['"]/.test(backendRuntimeSelftest)) {
+            failures.push('backend runtime selftest must not spawn a nested npm process');
+        }
+    }
+    const packageFiles = new Set((pkg.files || []).map(value => String(value).replace(/\\/g, '/')));
+    if (![...packageFiles].some(value => value.replace(/\/+$/, '') === 'build')) {
+        failures.push('package.json files must include the complete build directory');
+    }
+    for (const required of [
+        'tools/nexowatt-prebuilt-release-selftest.cjs',
+        'NEXOWATT_EOS_PREBUILT_MANIFEST.json',
+    ]) {
+        if (!packageFiles.has(required)) failures.push(`package.json files is missing ${required}`);
+    }
+}
+
+if (process.argv.includes('--write')) {
+    try {
+        writeManifest();
+    } catch (error) {
+        console.error(`[NexoWatt EOS prebuilt release] ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+
+const failures = [];
+verifyLifecycle(failures);
+const sealedCount = verifyManifest(failures);
+const runtimeCount = inspectRuntimeClosure(failures);
+
+if (failures.length) {
+    console.error(`[NexoWatt EOS prebuilt release] ${failures.length} failure(s):\n${failures.join('\n')}`);
+    process.exit(1);
+}
+console.log(
+    `[NexoWatt EOS prebuilt release] OK (${sealedCount} sealed source/runtime files; ${runtimeCount} backend runtime files; no tsc/tsx required for npm publish)`,
+);

package/tools/nexowatt-release-defaults-selftest.cjs

@@ -13,7 +13,7 @@ const unsafe = {
         eosHideLegacyAdminFromNonAdmins: false,
         eosHideLegacyBackupFromNonAdmins: false,
         nexowattHideLegacyBackupFromNonAdmins: false,
-        eosRequireFirstLoginPassword: false,
+        eosRequireFirstLoginPassword: true,
     },
 };
 const repaired = ensureReleaseDefaults(unsafe);

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: 7100 }));
+  fs.writeFileSync(path.join(temp, 'NEXOWATT_EOS_BUILD_INFO.json'), JSON.stringify({ runtimeEntry: 'v82', shellCacheVersion: 98 }));
 
   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-v7100.js',
-    'src-admin/public/static/js/nexowatt-stable-v7100.js',
+    'adminWww/static/js/nexowatt-stable-v98.js',
+    'src-admin/public/static/js/nexowatt-stable-v98.js',
     'adminWww/static/js/nexowatt-stable-login.js',
   ];
   const remove = [
@@ -34,10 +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',
+    'adminWww/static/js/nexowatt-stable-v97.js',
+    'src-admin/public/static/js/nexowatt-stable-v95.js',
   ];
   for (const rel of [...keep, ...remove]) {
     const file = path.join(temp, rel);
@@ -47,7 +45,7 @@ try {
 
   const result = cleanLegacyRuntime({ root: temp, quiet: true, silent: true });
   assert.strictEqual(result.activeRuntime, 82);
-  assert.strictEqual(result.activeShell, 7100);
+  assert.strictEqual(result.activeShell, 98);
   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-v7102-selftest.cjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const root = path.resolve(__dirname, '..');
+const read = relative => fs.readFileSync(path.join(root, relative), 'utf8');
+const json = relative => JSON.parse(read(relative));
+const must = (value, message) => {
+    if (!value) {
+        console.error(`[NexoWatt EOS stable v7102] ${message}`);
+        process.exit(1);
+    }
+};
+
+const pkg = json('package.json');
+const io = json('io-package.json');
+const info = json('NEXOWATT_EOS_BUILD_INFO.json');
+const main = read('src/main.ts');
+const web = read('src/lib/web.ts');
+const boot = read('adminWww/js/eos-role-bootstrap.js');
+const role = read('adminWww/js/eos-role-ui.js');
+const css = read('adminWww/css/nexowatt-native-shell.css');
+const index = read('adminWww/index.html');
+const ems = read('adminWww/js/eos-ems-overview.js');
+const intro = read('src-admin/src/tabs/Intro.tsx');
+const bundle = read('adminWww/assets/Intro-DkwRiz1n-v84.js');
+const stable = read('adminWww/static/js/nexowatt-stable-v7101.js');
+const auto = read('src/lib/eosAutoUpdate.ts');
+
+must(pkg.version === '7.10.2' && io.version === '7.10.2' && io.common.version === '7.10.2' && info.version === '7.10.2', 'version drift');
+must(io.native.eosRequireFirstLoginPassword === false && io.native.eosRequireFirstLoginPasswordChange === false, 'forced first password still enabled');
+must(!index.includes('eos-account-management.js'), 'custom reset UI still loaded');
+must(!boot.includes('installIntegratedFirstLogin(base);') && !boot.includes('showFirstLoginPassword(resolved, base);'), 'forced first-login UI still active');
+must(main.includes('standardPasswordMode: true') && main.includes('nexowattPasswordChangeRequired: false'), 'account migration missing');
+must(role.includes("route === 'tab-users'") && main.includes("command === 'changePassword'"), 'role-aware native password editing missing');
+must(css.includes('persistent native overview scrolling') && stable.includes("overflow-y','scroll"), 'persistent scroll missing');
+must(intro.includes('eos-overview-edit-controls') && bundle.includes('eos-overview-edit-controls'), 'edit control not in bottom grid');
+must(!ems.includes('Vollständige EMS-Diagnose öffnen'), 'unsupported EMS link remains');
+must(index.includes('eos-auto-update.js?v=7101') && auto.includes("const POLICY: NexoWattAutoUpdatePolicy = 'major'"), 'auto update missing');
+
+// 7.10.2 hotfix acceptance: no native writes on the running instance, delayed
+// startup reconciliation, cleanup on Web.close and complete backend package.
+must(auto.includes("const ENABLED_STATE_ID = 'info.nexowattStableUpdatesEnabled'"), 'restart-safe enabled state missing');
+must(auto.includes("const STATUS_STATE_ID = 'info.nexowattStableUpdatesState'"), 'restart-safe status state missing');
+must(auto.includes('const STARTUP_RECONCILE_DELAY_MS = 30_000'), 'startup grace period missing');
+must(!auto.includes('extendForeignObjectAsync(this.instanceId'), 'runtime still writes the running instance native configuration');
+must(web.includes('this.nexowattStableUpdateManager?.stop();'), 'auto-update manager is not stopped with the web server');
+must(fs.existsSync(path.join(root, 'build/lib/eosRequestSecurity.js')), 'eosRequestSecurity runtime module missing');
+
+console.log('[NexoWatt EOS stable v7102] OK (v7101 UI baseline plus restart-loop and package-completeness hotfix)');

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

@@ -19,6 +19,14 @@ function setValue(changes, label, object, key, value) {
     }
 }
 
+function setJsonValue(changes, label, object, key, value) {
+    const previous = object[key];
+    if (JSON.stringify(previous) !== JSON.stringify(value)) {
+        changes.push({ label, previous, value });
+        object[key] = value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+    }
+}
+
 function syncReleaseVersion(rootDir) {
     const root = path.resolve(rootDir);
     const packageFile = path.join(root, 'package.json');
@@ -32,10 +40,7 @@ function syncReleaseVersion(rootDir) {
         throw new Error(`Invalid package.json version: ${version || '<missing>'}`);
     }
 
-    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 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 = [];
 
@@ -65,7 +70,40 @@ function syncReleaseVersion(rootDir) {
             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);
+                    const rootPackage = json.packages[''];
+                    setValue(changes, 'package-lock.json packages[""] version', rootPackage, 'version', version);
+                    // A merge archive can update package.json while leaving stale release scripts,
+                    // files and policy metadata in package-lock.json. npm reads the lock root during
+                    // packaging, so keep every release-critical root field canonical as well.
+                    for (const key of [
+                        'name',
+                        'description',
+                        'license',
+                        'author',
+                        'private',
+                        'engines',
+                        'main',
+                        'files',
+                        'scripts',
+                        'dependencies',
+                        'devDependencies',
+                        'overrides',
+                        'keywords',
+                        'publishConfig',
+                        'nexowattReleasePolicy',
+                        'publisher',
+                        'copyright',
+                    ]) {
+                        if (Object.prototype.hasOwnProperty.call(pkg, key)) {
+                            setJsonValue(
+                                changes,
+                                `package-lock.json packages[""] ${key}`,
+                                rootPackage,
+                                key,
+                                pkg[key],
+                            );
+                        }
+                    }
                 }
             },
         },

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

@@ -3,11 +3,10 @@
 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 introBundle=read('adminWww/assets/Intro-DkwRiz1n-v84.js');const bootstrap=read('adminWww/assets/bootstrap-COulQZax-v84.js');const generic=read('adminWww/assets/index-D2ymscJA-v84.js');
 if(runtime!==source)fail('runtime source/build drift');
+if(runtime.includes('Vollständige EMS-Diagnose öffnen'))fail('unsupported EMS link remains');
 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=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');
+for(const marker of ['eos-ems-overview.css?v=7101','eos-ems-overview.js?v=7101','nexowatt-stable-v7101.js?v=7101'])if(!index.includes(marker))fail(`index marker missing: ${marker}`);
 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');
 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'")||!shell.includes('eosNativeReactOverview'))fail('native overview role bridge incomplete');