iobroker.eos-admin 7.9.95 → 7.9.96

package/tools/nexowatt-ems-overview-selftest.cjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const root = path.resolve(__dirname, '..');
+let failed = false;
+const fail = message => { console.error(`[NexoWatt EMS Overview Selftest] ERROR: ${message}`); failed = true; };
+const read = rel => { try { return fs.readFileSync(path.join(root, rel), 'utf8'); } catch (error) { fail(`${rel} nicht lesbar: ${error.message}`); return ''; } };
+const intro = read('src-admin/src/tabs/Intro.tsx');
+const component = read('src-admin/src/components/Intro/NexoWattEmsOverview.tsx');
+const css = read('src-admin/src/index.css');
+for (const marker of [
+    "import NexoWattEmsOverview from '@/components/Intro/NexoWattEmsOverview';",
+    '<NexoWattEmsOverview',
+]) if (!intro.includes(marker)) fail(`Intro-Vertrag fehlt: ${marker}`);
+for (const marker of [
+    'nexowatt-ems-overview-v1',
+    "getForeignStates('nexowatt-ui.*.info.adminOverview.*')",
+    'document.visibilityState',
+    'window.setInterval(() => void load(), 5_000)',
+    'Diagnose ist rein lesend',
+    'Vollständige EMS-Diagnose öffnen',
+    'system.adapter.nexowatt-ui.*.alive',
+]) if (!component.includes(marker)) fail(`Komponenten-Vertrag fehlt: ${marker}`);
+if ((component.match(/NexoWatt EMS · Live-Diagnose/g) || []).length !== 1) fail('EMS-Überschrift ist doppelt oder fehlt.');
+if (!css.includes('/* nexowatt-ems-overview-v1 */')) fail('Responsive EMS-CSS fehlt.');
+if (/setState\(|setForeignState\(|sendToHost\(/.test(component)) fail('EMS-Overview darf keine ioBroker-Schreiboperation enthalten.');
+const assetDir = path.join(root, 'admin', 'assets');
+if (fs.existsSync(assetDir)) {
+    const scripts = fs.readdirSync(assetDir).filter(name => name.endsWith('.js'));
+    const built = scripts.some(name => fs.readFileSync(path.join(assetDir, name), 'utf8').includes('nexowatt-ems-overview-v1'));
+    if (!built) fail('Gebautes Admin-Frontend enthält die EMS-Overview-Komponente nicht. Bitte npm run build ausführen.');
+}
+if (failed) process.exit(1);
+console.log('[NexoWatt EMS Overview Selftest] OK: read-only Diagnosekarte, Intro-Einbindung und responsive Darstellung geprüft.');

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

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CANONICAL_NATIVE_DEFAULTS = Object.freeze({
+    auth: true,
+    port: 8081,
+    eosLockLegacyAdmin: true,
+    eosHideLegacyAdminFromNonAdmins: true,
+    eosHideLegacyBackupFromNonAdmins: true,
+    nexowattHideLegacyBackupFromNonAdmins: true,
+    eosRequireFirstLoginPassword: true,
+});
+
+/**
+ * Enforce mandatory source defaults for every NexoWatt EOS sales release.
+ * This normalizes the repository io-package.json only. Existing installed
+ * instance configuration is not overwritten during adapter startup.
+ */
+function ensureReleaseDefaults(ioPackage) {
+    if (!ioPackage || typeof ioPackage !== 'object' || Array.isArray(ioPackage)) {
+        throw new TypeError('io-package.json must contain a JSON object');
+    }
+    const native = ioPackage.native && typeof ioPackage.native === 'object' && !Array.isArray(ioPackage.native)
+        ? ioPackage.native
+        : (ioPackage.native = {});
+    const changes = [];
+    for (const [key, value] of Object.entries(CANONICAL_NATIVE_DEFAULTS)) {
+        if (native[key] !== value) {
+            changes.push({ key, previous: native[key], value });
+            native[key] = value;
+        }
+    }
+    return {
+        ioPackage,
+        changed: changes.length > 0,
+        fields: changes.map(change => `native.${change.key}`),
+        changes,
+    };
+}
+
+function ensureFile(filePath) {
+    const absolute = path.resolve(filePath);
+    const parsed = JSON.parse(fs.readFileSync(absolute, 'utf8'));
+    const result = ensureReleaseDefaults(parsed);
+    if (result.changed) {
+        fs.writeFileSync(absolute, `${JSON.stringify(result.ioPackage, null, 2)}\n`, 'utf8');
+    }
+    return { file: absolute, ...result };
+}
+
+if (require.main === module) {
+    const root = path.resolve(__dirname, '..');
+    const target = process.argv[2] || path.join(root, 'io-package.json');
+    try {
+        const result = ensureFile(target);
+        if (result.changed) {
+            console.log(
+                `[NexoWatt EOS release defaults] repaired ${result.changes.length} canonical value(s): ${result.changes.map(change => change.key).join(', ')}`,
+            );
+        } else {
+            console.log('[NexoWatt EOS release defaults] OK (canonical sales defaults already present)');
+        }
+    } catch (error) {
+        console.error(`[NexoWatt EOS release defaults] ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+
+module.exports = { CANONICAL_NATIVE_DEFAULTS, ensureReleaseDefaults, ensureFile };

package/tools/nexowatt-generate-eos-admin-repo-entry.cjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+'use strict';
+const pkg = require('../package.json');
+const io = require('../io-package.json');
+const version = io.common.version || pkg.version;
+const base = (process.argv[2] || `https://unpkg.com/iobroker.eos-admin@${version}`).replace(/\/$/, '');
+const entry = {
+  'eos-admin': {
+    name: 'eos-admin',
+    version,
+    title: 'NexoWatt EOS Admin',
+    titleLang: io.common.titleLang,
+    desc: io.common.desc,
+    news: io.common.news,
+    meta: `${base}/io-package.json`,
+    icon: `${base}/admin/admin.png`,
+    extIcon: `${base}/admin/admin.svg`,
+    type: io.common.type || 'general',
+    mode: io.common.mode || 'daemon',
+    platform: io.common.platform || 'Javascript/Node.js',
+    connectionType: io.common.connectionType || 'local',
+    dataSource: io.common.dataSource || 'push',
+    adminUI: io.common.adminUI || { config: 'json' },
+    license: io.common.license || 'NexoWatt Proprietary',
+    licenseInformation: io.common.licenseInformation,
+    dependencies: io.common.dependencies || [{ 'js-controller': '>=6.0.11' }],
+    stopBeforeUpdate: false,
+    dontDelete: false,
+    nondeletable: false,
+    readme: `${base}/README.md`,
+    packetName: 'iobroker.eos-admin',
+    npmPackage: 'iobroker.eos-admin',
+    allowAdapterUpdate: true,
+    allowAdapterDelete: false,
+  }
+};
+console.log(JSON.stringify(entry, null, 2));

package/tools/nexowatt-generate-repo-entry.cjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict';
+require('./nexowatt-generate-eos-admin-repo-entry.cjs');

package/tools/nexowatt-internal-reserve-selftest.cjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const root = path.resolve(__dirname, '..');
+const read = rel => fs.readFileSync(path.join(root, rel), 'utf8');
+const json = rel => JSON.parse(read(rel));
+let bad = false;
+const fail = msg => { console.error(`[NexoWatt EOS internal reserve] ${msg}`); bad = true; };
+
+const mainSource = read('src/main.ts');
+const mainBuilt = read('build/main.js');
+const webSource = read('src/lib/web.ts');
+const webBuilt = read('build/lib/web.js');
+const role = read('adminWww/js/eos-role-ui.js');
+const boot = read('adminWww/js/eos-role-bootstrap.js');
+const drawer = read('src-admin/src/components/Drawer.tsx');
+const assist = read('adminWww/js/eos-assistant.js');
+const io = json('io-package.json');
+
+for (const code of [mainSource, mainBuilt]) {
+  for (const marker of [
+    "LEGACY_BACKUP_ADAPTER_NAME = 'backitup'", 'shouldHideLegacyBackupFromNonAdmins',
+    'getLegacyBackupAclObjectIds', 'ensureLegacyBackupVisibleOnlyToAdmins',
+    'EOS ACL guard restricted internal', '/^system\\.adapter\\.(?:admin|backitup)(?:\\.|$)/',
+    '/^(?:admin|backitup)\\.\\d+(?:\\.|$)/', 'internal Service reserve is Admin/Service-only',
+  ]) if (!code.includes(marker)) fail(`backend reserve marker missing: ${marker}`);
+}
+for (const code of [webSource, webBuilt]) {
+  for (const marker of [
+    "LEGACY_BACKUP_ADAPTER_NAME = 'backitup'", "CUSTOMER_BACKUP_ADAPTER_NAMES = ['nexowatt-backup', 'eos-backup']",
+    'nexowattBackup: true', "internalBackupReserve: role === 'admin'", 'hideLegacyBackupFromNonAdmins',
+    'legacyBackupAdapter', 'customerBackupAdapters',
+  ]) if (!code.includes(marker)) fail(`web reserve marker missing: ${marker}`);
+}
+for (const marker of [
+  'isOfficialAdminTab', 'isOfficialBackupTab', 'isOfficialReserveTab', 'isCustomerBackupTab',
+  'system.adapter.backitup', 'tab-backitup', 'nexowatt-backup', 'eos-backup',
+  'exact visible instance ID', 'data-eos-official-reserve-hidden', 'Reused virtual rows must be unhidden',
+]) if (!role.includes(marker)) fail(`role UI reserve marker missing: ${marker}`);
+for (const marker of ['isOfficialReserveTab', 'isCustomerBackupTab', 'backitup', 'nexowatt-backup']) {
+  if (!boot.includes(marker)) fail(`bootstrap reserve marker missing: ${marker}`);
+}
+for (const marker of ['System-Notfallsicherung', 'NexoWatt Sicherung', '^tab-backitup', 'nexowatt-backup|eos-backup']) {
+  if (!drawer.includes(marker)) fail(`Drawer reserve marker missing: ${marker}`);
+}
+if (!assist.includes('NEXOWATT_EOS_ASSIST_DISABLED')) fail('EOS Assist must remain disabled in the stable reserve test');
+if (io.native?.eosHideLegacyBackupFromNonAdmins !== true) fail('eosHideLegacyBackupFromNonAdmins must default to true');
+if (io.native?.nexowattHideLegacyBackupFromNonAdmins !== true) fail('nexowattHideLegacyBackupFromNonAdmins must default to true');
+const reserve = (io.native?.eosProtectedAdapters || []).find(entry => entry.adapter === 'backitup');
+if (!reserve?.enabled || !/Notfallreserve/i.test(String(reserve.note))) fail('backitup reserve is not clearly marked in the protected adapter defaults');
+if (role.includes("/^tab-(?:admin|backitup|nexowatt-backup)/")) fail('customer backup must not be grouped with internal reserves');
+
+if (bad) process.exit(1);
+console.log('[NexoWatt EOS internal reserve] OK');

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

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+const read = rel => fs.readFileSync(path.join(root, rel), 'utf8');
+let bad = false;
+const fail = message => {
+    console.error(`[NexoWatt EOS login layout] ${message}`);
+    bad = true;
+};
+
+const css = read('adminWww/css/nexowatt-native-shell.css');
+const sourceCss = read('src-admin/public/css/nexowatt-native-shell.css');
+const login = read('src-admin/src/login/Login.tsx');
+const bootstrap = read('adminWww/js/eos-role-bootstrap.js');
+const index = read('adminWww/index.html');
+const buildInfo = JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));
+const shellTag = String(buildInfo.shellCacheTag || buildInfo.shellCacheVersion || '');
+
+if (css !== sourceCss) fail('login CSS source/build drift');
+if (!css.includes('outer frame is decorative only')) fail('decorative compact-frame contract is missing');
+if (css.includes('html.eos-login .MuiPaper-root:has(#username)')) {
+    fail('broad :has selector still styles the outer login Paper');
+}
+
+const outer = css.match(/html\.eos-login main\.MuiPaper-root\s*\{([\s\S]*?)\n\}/)?.[1] || '';
+for (const marker of [
+    'position: relative',
+    'width: 100%',
+    'min-height: 100vh',
+    'place-items: center',
+    'background: transparent !important',
+    'box-shadow: none !important',
+]) {
+    if (!outer.includes(marker)) fail(`transparent viewport host rule missing: ${marker}`);
+}
+
+const decorative = css.match(/html\.eos-login main\.MuiPaper-root::before\s*\{([\s\S]*?)\n\}/)?.[1] || '';
+for (const marker of [
+    "content: ''",
+    'width: min(520px, calc(100vw - 24px)) !important',
+    'height: min(640px, calc(100dvh - 24px)) !important',
+    'transform: translate(-50%, -50%)',
+    'pointer-events: none',
+]) {
+    if (!decorative.includes(marker)) fail(`decorative rear frame rule missing: ${marker}`);
+}
+
+for (const marker of [
+    'html.eos-login main.MuiPaper-root > .eos-login-card-modern',
+    'html.eos-login main.MuiPaper-root > .MuiPaper-root:has(#username)',
+    'html.eos-login main.MuiPaper-root > .MuiPaper-root:has(#password)',
+    'width: min(460px, calc(100vw - 56px)) !important',
+    'min-height: 540px !important',
+    'height: auto !important',
+    'overflow: visible !important',
+    'max-height: none !important',
+]) {
+    if (!css.includes(marker)) fail(`inner compact card rule missing: ${marker}`);
+}
+if (!css.includes('.eos-login-first-status:empty { display: none; min-height: 0; margin: 0; }')) {
+    fail('empty first-login status still reserves vertical space');
+}
+
+if (!login.includes('Keep the familiar compact login page')) fail('native Login source lacks spacious-page contract');
+if (login.includes('eos-login-role-selector-native') || login.includes('data-eos-account=')) {
+    fail('native Login source still renders role-selector buttons');
+}
+if (!bootstrap.includes('compact normal-login first activation')) fail('runtime compact first-login contract missing');
+if (!bootstrap.includes("card.querySelectorAll('.eos-login-role-selector').forEach(element => element.remove())")) {
+    fail('runtime does not remove stale role-selector surfaces');
+}
+if (/data-eos-account=|selector\.innerHTML/.test(bootstrap)) fail('runtime still injects a second role-selector panel');
+
+if (!shellTag || !index.includes(`nexowatt-native-shell.css?v=${shellTag}`)) {
+    fail('login CSS cache key is not aligned with build information');
+}
+
+if (bad) process.exit(1);
+console.log('[NexoWatt EOS login layout] OK');

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

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const root = path.resolve(__dirname, '..');
+const fail = message => {
+    console.error(`[NexoWatt EOS merge update selftest] ${message}`);
+    process.exit(1);
+};
+const read = file => fs.readFileSync(path.join(root, file), 'utf8');
+const exists = file => fs.existsSync(path.join(root, file));
+
+for (const file of [
+    'MERGE_UPDATE.ps1',
+    'MERGE_UPDATE.cmd',
+    'MERGE_UPDATE.sh',
+    'MERGE_UPDATE_README_V7.9.96.md',
+    'tools/nexowatt-apply-ems-overview.cjs',
+    'tools/nexowatt-sync-release-version.cjs',
+    'tools/nexowatt-version-sync-selftest.cjs',
+]) {
+    if (!exists(file)) fail(`${file} is missing`);
+}
+
+const ps = read('MERGE_UPDATE.ps1');
+for (const marker of [
+    '$PSScriptRoot',
+    'nexowatt-apply-ems-overview.cjs',
+    'nexowatt-sync-release-version.cjs',
+    'npm run check:eos-package',
+    'npm run check:eos-stability',
+    'npm pack --dry-run',
+]) {
+    if (!ps.includes(marker)) fail(`MERGE_UPDATE.ps1 is missing ${marker}`);
+}
+if (/npm\s+publish/i.test(ps)) fail('MERGE_UPDATE.ps1 must never publish automatically');
+
+const cmd = read('MERGE_UPDATE.cmd');
+if (!cmd.includes('MERGE_UPDATE.ps1') || !/ExecutionPolicy\s+Bypass/i.test(cmd)) {
+    fail('MERGE_UPDATE.cmd does not start the guarded PowerShell verifier');
+}
+
+const sh = read('MERGE_UPDATE.sh');
+for (const marker of [
+    'set -euo pipefail',
+    'nexowatt-apply-ems-overview.cjs',
+    'npm run sync:eos-version',
+    'npm run check:eos-package',
+    'npm run check:eos-stability',
+    'npm pack --dry-run',
+]) {
+    if (!sh.includes(marker)) fail(`MERGE_UPDATE.sh is missing ${marker}`);
+}
+if (/npm\s+publish/i.test(sh)) fail('MERGE_UPDATE.sh must never publish automatically');
+
+const pkg = JSON.parse(read('package.json'));
+if (pkg.scripts['sync:eos-version'] !== 'node tools/nexowatt-sync-release-version.cjs') {
+    fail('sync:eos-version script is not canonical');
+}
+if (!pkg.scripts['precheck:eos-package']?.startsWith('npm run sync:eos-version')) {
+    fail('package validation does not self-heal stale merged version files');
+}
+if (!pkg.scripts.prepublishOnly?.startsWith('npm run sync:eos-version')) {
+    fail('npm publishing does not self-heal stale merged version files');
+}
+
+console.log('[NexoWatt EOS merge update selftest] OK (flat overwrite + EMS merge + version repair + guarded verification)');

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const root = path.resolve(__dirname, '..');
+const read = rel => fs.readFileSync(path.join(root, rel), 'utf8');
+let bad = false;
+const fail = msg => { console.error(`[NexoWatt EOS modern UI] ${msg}`); bad = true; };
+const css = read('adminWww/css/nexowatt-native-shell.css');
+const sourceCss = read('src-admin/public/css/nexowatt-native-shell.css');
+const index = read('adminWww/index.html');
+const accountUi = read('adminWww/js/eos-account-management.js');
+const bootstrap = read('adminWww/js/eos-role-bootstrap.js');
+const shell = read('adminWww/js/nexowatt-native-shell.js');
+const role = read('adminWww/js/eos-role-ui.js');
+const assist = read('adminWww/js/eos-assistant.js');
+
+for (const marker of [
+  '--nx-shadow-soft', '--nx-shadow-float', 'backdrop-filter: blur', '#app-paper', '.MuiDialog-paper',
+  '.MuiButton-root', '.MuiTableRow-root', ':focus-visible', 'border-radius: 24px', 'linear-gradient',
+  '@media (max-width: 720px)', '.eos-activation-steps', '.eos-account-row:hover',
+  'main.MuiPaper-root::before', 'width: min(460px, calc(100vw - 56px)) !important', '.eos-assist-header-root', '.eos-overview-hero', '.eos-overview-grid',
+  '.eos-account-management-entry', 'pointer-events: auto !important', 'touch-action: manipulation', 'overflow: visible',
+]) if (!css.includes(marker)) fail(`modern styling marker missing: ${marker}`);
+if (sourceCss !== css) fail('modern CSS source/build drift');
+for (const marker of ['eos-account-management.js','nexowatt-native-shell.css','eos-role-bootstrap.js','eos-assistant.js']) {
+  if (!index.includes(marker)) fail(`modern UI asset not active: ${marker}`);
+}
+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','v96 compact 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');
+if (bootstrap.includes("launcher.className = 'eos-passwordless-launcher'")) fail('old bottom first-login launcher is still rendered');
+if (!shell.includes('ensureModernOverview') || !shell.includes("currentTab() !== 'tab-intro'")) fail('current overview is not modernized');
+if (!role.includes('never cover the real Admin Intro') || role.includes('overview.innerHTML = `') || !role.includes('navigateToTab')) fail('native role overview contract is missing');
+if (!role.includes('ensureReserveObserver') || !role.includes('state.reserveObserver.observe(paper')) fail('scoped delayed-row reserve filter is missing');
+if (!assist.includes('NEXOWATT_EOS_ASSIST_DISABLED') || !assist.includes('element.remove()')) fail('EOS Assist stable-disable guard is missing');
+
+const observerCount = [
+  'eos-policy-client.js', 'eos-branding-sanitizer.js', 'nexowatt-native-shell.js', 'eos-native-security.js',
+  'eos-basic-settings.js', 'eos-role-ui.js', 'eos-account-management.js', 'eos-assistant.js',
+].reduce((count, file) => count + (read(`adminWww/js/${file}`).match(/new MutationObserver/g) || []).length, 0);
+if (observerCount !== 2) fail(`expected one shared observer plus one scoped reserve-row observer, found ${observerCount}`);
+
+if (bad) process.exit(1);
+console.log('[NexoWatt EOS modern UI] OK');

package/tools/nexowatt-patch-repo.cjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const input = process.argv[2];
+const output = process.argv[3] || input;
+const version = process.argv[4] || require('../package.json').version;
+const baseUrl = (process.argv[5] || `https://unpkg.com/iobroker.eos-admin@${version}`).replace(/\/$/, '');
+if (!input) {
+  console.error('Usage: node tools/nexowatt-patch-repo.cjs <repo-nexowatt.json> [output.json] [version] [base-url]');
+  process.exit(2);
+}
+const repo = JSON.parse(fs.readFileSync(input, 'utf8'));
+const ioPath = path.join(__dirname, '..', 'io-package.json');
+const io = JSON.parse(fs.readFileSync(ioPath, 'utf8'));
+repo['eos-admin'] = {
+  ...(repo['eos-admin'] || {}),
+  name: 'eos-admin',
+  version,
+  title: 'NexoWatt EOS Admin',
+  titleLang: io.common.titleLang,
+  desc: {
+    de: 'Eigenständige NexoWatt EOS Administrationsoberfläche mit zuverlässigem In-App-Updatepfad für Energy Operation System Installationen.',
+    en: 'Standalone NexoWatt EOS administration interface with reliable in-app update flow for Energy Operation System installations.',
+  },
+  news: io.common.news,
+  meta: `${baseUrl}/io-package.json`,
+  icon: `${baseUrl}/admin/admin.png`,
+  extIcon: `${baseUrl}/admin/admin.svg`,
+  type: 'general',
+  mode: 'daemon',
+  platform: 'Javascript/Node.js',
+  connectionType: 'local',
+  dataSource: 'push',
+  adminUI: { config: 'json' },
+  license: 'NexoWatt Proprietary',
+  licenseInformation: io.common.licenseInformation,
+  dependencies: [{ 'js-controller': '>=6.0.11' }],
+  stopBeforeUpdate: false,
+  dontDelete: false,
+  nondeletable: false,
+  readme: `${baseUrl}/README.md`,
+  packetName: 'iobroker.eos-admin',
+    npmPackage: 'iobroker.eos-admin',
+  allowAdapterUpdate: true,
+  allowAdapterDelete: false,
+};
+fs.writeFileSync(output, JSON.stringify(repo, null, 2) + '\n');
+console.log(`Patched ${input} -> ${output}`);
+console.log(`repo["eos-admin"].version=${version}`);
+console.log(`repo["eos-admin"].meta=${repo['eos-admin'].meta}`);
+console.log('repo["eos-admin"].stopBeforeUpdate=false');
+console.log('repo["eos-admin"].dontDelete=false');
+console.log('repo["eos-admin"].nondeletable=false');

package/tools/nexowatt-publish-channel-guard.cjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function validatePublishChannel(pkg, env = process.env) {
+    const version = String(pkg?.version || '').trim();
+    const configuredTag = String(pkg?.publishConfig?.tag || '').trim();
+    const requestedTag = String(env.npm_config_tag || env.NPM_CONFIG_TAG || configuredTag || 'latest').trim();
+    const isPrerelease = version.includes('-');
+    const policy = pkg?.nexowattReleasePolicy || {};
+
+    if (!version) {
+        return { ok: false, message: 'package.json version is missing' };
+    }
+    if (configuredTag !== 'latest' || requestedTag !== 'latest') {
+        return {
+            ok: false,
+            message: `${version} is approved only for npm dist-tag latest, got configured=${configuredTag || '<unset>'}, requested=${requestedTag || '<unset>'}`,
+        };
+    }
+
+    if (isPrerelease) {
+        if (policy.distTag !== 'latest' || policy.acceptedPrerelease !== version) {
+            return {
+                ok: false,
+                message: `Prerelease ${version} may move latest only when nexowattReleasePolicy explicitly accepts this exact version`,
+            };
+        }
+        return { ok: true, version, tag: 'latest', prerelease: true, explicitlyAccepted: true };
+    }
+
+    if (policy.acceptedPrerelease) {
+        return {
+            ok: false,
+            message: `Stable version ${version} must remove stale acceptedPrerelease policy ${policy.acceptedPrerelease}`,
+        };
+    }
+    return { ok: true, version, tag: 'latest', prerelease: false, explicitlyAccepted: false };
+}
+
+if (require.main === module) {
+    const root = path.resolve(__dirname, '..');
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const result = validatePublishChannel(pkg, process.env);
+
+    if (!result.ok) {
+        console.error(`[NexoWatt EOS publish guard] ${result.message}`);
+        process.exit(1);
+    }
+
+    console.log(
+        `[NexoWatt EOS publish guard] OK (${result.version}, npm dist-tag latest${result.explicitlyAccepted ? '; exact prerelease acceptance recorded' : ''})`,
+    );
+}
+
+module.exports = { validatePublishChannel };

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

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const { CANONICAL_NATIVE_DEFAULTS, ensureReleaseDefaults } = require('./nexowatt-ensure-release-defaults.cjs');
+
+const unsafe = {
+    common: { name: 'eos-admin' },
+    native: {
+        auth: false,
+        port: 8091,
+        eosLockLegacyAdmin: false,
+        eosHideLegacyAdminFromNonAdmins: false,
+        eosHideLegacyBackupFromNonAdmins: false,
+        nexowattHideLegacyBackupFromNonAdmins: false,
+        eosRequireFirstLoginPassword: false,
+    },
+};
+const repaired = ensureReleaseDefaults(unsafe);
+assert.ok(repaired.changes.length >= 7, 'unsafe defaults must be repaired');
+for (const [key, expected] of Object.entries(CANONICAL_NATIVE_DEFAULTS)) {
+    assert.equal(repaired.ioPackage.native[key], expected, `${key} must be normalized`);
+}
+
+const canonical = { native: { ...CANONICAL_NATIVE_DEFAULTS } };
+const unchanged = ensureReleaseDefaults(canonical);
+assert.equal(unchanged.changes.length, 0, 'canonical defaults must remain unchanged');
+
+console.log('[NexoWatt EOS release defaults selftest] OK');

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

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { cleanLegacyRuntime } = require('./nexowatt-clean-legacy-runtime.cjs');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'nexowatt-runtime-cleanup-'));
+try {
+  fs.mkdirSync(path.join(temp, 'adminWww', 'assets'), { recursive: true });
+  fs.mkdirSync(path.join(temp, 'adminWww', 'js'), { recursive: true });
+  fs.mkdirSync(path.join(temp, 'adminWww', 'css'), { recursive: true });
+  fs.mkdirSync(path.join(temp, 'src-admin', 'public', 'js'), { recursive: true });
+  fs.writeFileSync(path.join(temp, 'NEXOWATT_EOS_BUILD_INFO.json'), JSON.stringify({ runtimeEntry: 'v82' }));
+
+  const keep = [
+    'adminWww/assets/bootstrap-current-v82.js',
+    'adminWww/assets/Objects-current-v82.js',
+    'adminWww/remoteEntry-v82.js',
+    'adminWww/remoteEntry.js',
+  ];
+  const remove = [
+    'adminWww/assets/bootstrap-old-v54.js',
+    'adminWww/assets/Objects-old-v79.js',
+    'adminWww/assets/index-DPWrite53.js',
+    'adminWww/remoteEntry-v61.js',
+    'adminWww/js/eos-branding.js',
+    'adminWww/css/eos-branding.css',
+    'src-admin/public/js/eos-security-ui.js',
+  ];
+  for (const rel of [...keep, ...remove]) {
+    const file = path.join(temp, rel);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, '// fixture');
+  }
+
+  const result = cleanLegacyRuntime({ root: temp, quiet: true, silent: true });
+  assert.strictEqual(result.activeRuntime, 82);
+  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}`);
+  console.log('[NexoWatt EOS runtime cleanup selftest] OK');
+} finally {
+  fs.rmSync(temp, { recursive: true, force: true });
+}

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

@@ -0,0 +1,13 @@
+#!/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 must=(ok,msg)=>{if(!ok){console.error(`[NexoWatt EOS stable v96] ${msg}`);process.exit(1)}};
+const pkg=JSON.parse(read('package.json'));const io=JSON.parse(read('io-package.json'));const info=JSON.parse(read('NEXOWATT_EOS_BUILD_INFO.json'));const css=read('adminWww/css/nexowatt-native-shell.css');const boot=read('adminWww/js/eos-role-bootstrap.js');const role=read('adminWww/js/eos-role-ui.js');const stable=read('adminWww/static/js/nexowatt-stable-v96.js');const index=read('adminWww/index.html');
+must(pkg.version==='7.9.96'&&io.version==='7.9.96'&&io.common.version==='7.9.96'&&info.version==='7.9.96','version drift');
+must(info.shellCacheVersion===96&&info.shellCacheTag==='96','shell cache is not v96');
+must(css.includes('width: min(460px, calc(100vw - 56px)) !important')&&css.includes('overflow: visible !important'),'spacious login override missing');
+must(!/showFirstLoginPassword[\s\S]{0,5000}form\.elements\.username\.value = claim\.userName/.test(boot),'undefined claim variable remains in first-password flow');
+must(boot.includes('form.elements.username.value = userName;')&&boot.includes('controller.abort(), 8000'),'first-password repair incomplete');
+must(role.includes('never cover the real Admin Intro')&&!role.includes('overview.innerHTML = `'),'old action-tile overview remains');
+must(stable.includes("VERSION = 'v96-spacious-login-first-password-fix'")&&stable.includes('width:min(460px'),'stable v96 login runtime incomplete');
+must(index.includes('nexowatt-stable-v96.js?v=96'),'stable v96 runtime not loaded');
+console.log('[NexoWatt EOS stable v96] OK');