iobroker.bee 0.0.0-stage → 0.2.2

package/build/main.js

@@ -0,0 +1,835 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = __importStar(require("@iobroker/adapter-core"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = require("node:path");
+const commands_1 = require("./lib/commands");
+const console_1 = require("./lib/console");
+const enrollment_1 = require("./lib/enrollment");
+const inventory_1 = require("./lib/inventory");
+const jobs_1 = require("./lib/jobs");
+const packages_1 = require("./lib/packages");
+const planner_1 = require("./lib/planner");
+const preflight_1 = require("./lib/preflight");
+const protocol_1 = require("./lib/protocol");
+const remote_1 = require("./lib/remote");
+const transport_1 = require("./lib/transport");
+const tunnel_1 = require("./lib/tunnel");
+const util_1 = require("./lib/util");
+class BeeAdapter extends utils.Adapter {
+    dataDir = '';
+    creds = null;
+    transport = null;
+    jobs = null;
+    desired = null;
+    control = null;
+    persisted = { results: {}, lastResult: null, lastBackup: null, notified: {} };
+    timers = [];
+    enrollTimer = null;
+    enrollBackoff = 30_000;
+    seq = 0;
+    lastFlat = null;
+    uuid = '';
+    errorLog = [];
+    errorsSinceHeartbeat = 0;
+    reconciling = false;
+    /** A command of the fleet management is being carried out (one at a time) */
+    commandRunning = false;
+    lastWaitReason = '';
+    unloading = false;
+    /** Open remote access sessions by session id */
+    tunnels = new Map();
+    /** Running shells of the console per session */
+    shells = new Map();
+    constructor(options = {}) {
+        super({ ...options, name: 'bee' });
+        this.on('ready', () => this.onReady());
+        this.on('stateChange', (id, state) => this.onStateChange(id, state));
+        this.on('unload', callback => void this.onUnload(callback));
+        this.on('log', (msg) => this.onLog(msg));
+    }
+    // ------------------------------------------------------------------ lifecycle
+    async onReady() {
+        this.dataDir = utils.getAbsoluteInstanceDataDir(this);
+        (0, node_fs_1.mkdirSync)(this.dataDir, { recursive: true });
+        await this.setState('info.connection', false, true);
+        const meta = await this.getForeignObjectAsync('system.meta.uuid');
+        this.uuid = meta?.native?.uuid || '';
+        this.persisted = { ...this.persisted, ...(await (0, util_1.readJson)((0, node_path_1.join)(this.dataDir, 'state.json'))) };
+        this.desired = await (0, util_1.readJson)((0, node_path_1.join)(this.dataDir, 'desired.json'));
+        this.control = await (0, util_1.readJson)((0, node_path_1.join)(this.dataDir, 'control.json'));
+        this.jobs = new jobs_1.JobManager({
+            dataDir: this.dataDir,
+            iobrokerJs: (0, node_path_1.join)(utils.controllerDir, 'iobroker.js'),
+            cwd: (0, node_path_1.join)(utils.controllerDir, '..', '..'),
+            log: this.log,
+            verifySeconds: this.config.verifySeconds || 120,
+            startTimeoutSeconds: this.config.startTimeoutSeconds || 300,
+            report: job => this.reportJob(job),
+            installed: async () => (0, inventory_1.installedVersions)(await this.inventory()),
+            instancesOf: adapter => this.instancesOf(adapter),
+            errorsSince: (ts, adapters) => this.errorLog.filter(e => e.ts >= ts && adapters.some(a => e.from.startsWith(`${a}.`))),
+            onFinished: (job, result) => this.onJobFinished(job, result),
+        });
+        await this.jobs.load();
+        await this.jobs.setHalt(!!this.control?.halt);
+        // count error log lines of all instances (verification and heartbeat)
+        await this.requireLog?.(true);
+        await this.subscribeStatesAsync('control.*');
+        await this.updateInfoStates();
+        this.creds = await (0, util_1.readJson)((0, node_path_1.join)(this.dataDir, 'device.json'));
+        await this.updateAccessStates();
+        if (this.creds) {
+            this.startTransport();
+            // sessions that were open before a restart (e.g. after a change of the settings)
+            for (const t of (await (0, util_1.readJson)((0, node_path_1.join)(this.dataDir, 'tunnels.json'))) || []) {
+                await this.openTunnel(t, true);
+            }
+        }
+        else {
+            await this.tryEnroll();
+        }
+        this.timers.push(setInterval(() => void this.jobs?.poll(), 2000));
+        this.timers.push(setInterval(() => void this.heartbeat(), (this.config.heartbeatMinutes || 60) * 60_000));
+        this.timers.push(setInterval(() => {
+            void this.sendInventory(false);
+            void this.reconcile();
+        }, (this.config.checkMinutes || 5) * 60_000));
+    }
+    async onUnload(callback) {
+        this.unloading = true;
+        try {
+            this.timers.forEach(t => clearInterval(t));
+            if (this.enrollTimer) {
+                clearTimeout(this.enrollTimer);
+            }
+            // the sessions stay in tunnels.json and are resumed after the restart
+            for (const client of [...this.tunnels.values()]) {
+                client.stop('agent stops');
+            }
+            // js-controller kills slow adapters; the Last Will covers a disconnect that does not finish in time
+            await Promise.race([this.transport?.stop(), new Promise(resolve => setTimeout(resolve, 800))]);
+            await this.setState('info.connection', false, true);
+        }
+        finally {
+            callback();
+        }
+    }
+    async savePersisted() {
+        await (0, util_1.writeJsonAtomic)((0, node_path_1.join)(this.dataDir, 'state.json'), this.persisted);
+    }
+    // ------------------------------------------------------------------ enrollment
+    async stopWithReason(reason) {
+        this.log.error(`Beekeeper rejected this device: ${reason}. The agent stops.`);
+        await this.setState('info.status', `Abgewiesen: ${reason}`, true);
+        await this.notify('rejected', `Die Flottenverwaltung hat dieses Gerät abgewiesen: ${reason}`);
+        // explicit rejection: stop instead of knocking again; js-controller does not restart us
+        this.terminate(reason, utils.EXIT_CODES.ADAPTER_REQUESTED_TERMINATION);
+    }
+    async tryEnroll() {
+        if (!this.config.enrollUrl || !this.config.enrollToken) {
+            await this.setState('info.status', 'Nicht konfiguriert: Enrollment-URL und Token fehlen', true);
+            this.log.warn('Enrollment URL or token missing, please configure the adapter');
+            return;
+        }
+        await this.setState('info.status', 'Anmeldung beim Server …', true);
+        const result = await (0, enrollment_1.enroll)(this.config.enrollUrl, {
+            token: this.config.enrollToken,
+            uuid: this.uuid,
+            hostname: node_os_1.default.hostname(),
+            agentVersion: this.version,
+            comment: (0, protocol_1.normalizeComment)(this.config.comment),
+        });
+        if (result.kind === 'ok') {
+            this.creds = result.creds;
+            await (0, util_1.writeJsonAtomic)((0, node_path_1.join)(this.dataDir, 'device.json'), result.creds);
+            this.log.info(`Enrolled as ${result.creds.deviceId} (asset ${result.creds.assetId})`);
+            await this.updateInfoStates();
+            this.startTransport();
+        }
+        else if (result.kind === 'rejected') {
+            await this.stopWithReason(result.reason);
+        }
+        else {
+            // network or server trouble is no reason to stop: retry with growing distance
+            const delay = this.enrollBackoff;
+            this.enrollBackoff = Math.min(this.enrollBackoff * 2, 24 * 3600_000);
+            this.log.warn(`Enrollment failed (${result.reason}), retry in ${Math.round(delay / 1000)} s`);
+            await this.setState('info.status', `Anmeldung fehlgeschlagen, neuer Versuch in ${Math.round(delay / 60000)} min`, true);
+            this.enrollTimer = setTimeout(() => {
+                this.enrollTimer = null;
+                void this.tryEnroll();
+            }, delay);
+        }
+    }
+    // ------------------------------------------------------------------ transport
+    startTransport() {
+        const transport = new transport_1.Transport(this.creds, { keepalive: this.config.keepaliveSeconds || 300, log: this.log });
+        this.transport = transport;
+        transport.on('connected', () => void this.onConnected());
+        transport.on('disconnected', () => {
+            void this.setState('info.connection', false, true);
+        });
+        transport.on('desired', msg => void this.onDesired(msg));
+        transport.on('control', msg => void this.onControl(msg));
+        transport.on('job', msg => void this.onJob(msg));
+        transport.on('rejected', reason => void this.stopWithReason(reason));
+        transport.start();
+    }
+    async onConnected() {
+        this.log.info('Connected to beekeeper');
+        await this.setState('info.connection', true, true);
+        await this.setState('info.status', 'Verbunden', true);
+        await this.heartbeat();
+        await this.sendInventory(true);
+        // results produced while offline
+        if (this.jobs?.job) {
+            await this.reportJob(this.jobs.job);
+        }
+        else if (this.persisted.lastResult) {
+            await this.transport?.publish('result', this.persisted.lastResult);
+        }
+    }
+    async onDesired(msg) {
+        this.desired = msg;
+        await (0, util_1.writeJsonAtomic)((0, node_path_1.join)(this.dataDir, 'desired.json'), msg);
+        this.log.info(msg?.profile
+            ? `Desired state: ${msg.profile.name} (${msg.mode}${msg.retry ? `, retry ${msg.retry}` : ''})`
+            : 'No desired state');
+        await this.updateInfoStates();
+        this.lastWaitReason = '';
+        await this.reconcile();
+    }
+    async onControl(msg) {
+        // log only real changes, not the retained state delivered on every connect
+        const changed = msg.halt !== !!this.control?.halt;
+        this.control = msg;
+        await (0, util_1.writeJsonAtomic)((0, node_path_1.join)(this.dataDir, 'control.json'), msg);
+        await this.jobs?.setHalt(msg.halt);
+        await this.setState('control.halted', msg.halt, true);
+        if (changed) {
+            this.log.warn(msg.halt ? `Emergency stop: ${msg.reason || 'no reason given'}` : 'Emergency stop released');
+            if (!msg.halt) {
+                await this.reconcile();
+            }
+        }
+    }
+    async onJob(msg) {
+        if (msg.cmd === 'resync' || msg.cmd === 'refresh') {
+            await this.sendInventory(true);
+        }
+        else if (msg.cmd === 'tunnel' && msg.tunnel) {
+            await this.openTunnel(msg.tunnel, false);
+        }
+        else if (msg.ref && (msg.cmd === 'instance' || msg.cmd === 'restart' || msg.cmd === 'osUpgrade')) {
+            await this.runCommand(msg);
+        }
+    }
+    // ------------------------------------------------------------------ commands of the fleet management
+    async reply(ref, state, message) {
+        const msg = { v: protocol_1.PROTOCOL_VERSION, ts: Date.now(), ref, state, ...(message ? { message } : {}) };
+        await this.transport?.publish('reply', msg);
+    }
+    /** Sends the inventory again a while after a command, when the instances show its effect */
+    inventorySoon() {
+        for (const ms of [5_000, 30_000]) {
+            this.timers.push(setTimeout(() => void this.sendInventory(false), ms));
+        }
+    }
+    async runCommand(msg) {
+        const ref = msg.ref;
+        const by = msg.by || 'Flottenverwaltung';
+        if (this.reconciling || this.jobs?.isActive()) {
+            await this.reply(ref, 'error', 'Während eines Auftrags (Update) nicht möglich');
+            return;
+        }
+        if (this.commandRunning) {
+            await this.reply(ref, 'error', 'Es läuft schon ein Befehl');
+            return;
+        }
+        this.commandRunning = true;
+        try {
+            if (msg.cmd === 'instance') {
+                await this.instanceCommand(ref, by, msg.instance);
+            }
+            else if (msg.cmd === 'restart') {
+                this.log.warn(`Restart of ioBroker on request of ${by} (fleet management)`);
+                // the answer goes out first, the restart takes the agent down too
+                await this.reply(ref, 'done', 'ioBroker startet neu');
+                this.sendToHost(`system.host.${this.host}`, 'restartController', {});
+            }
+            else if (msg.cmd === 'osUpgrade') {
+                await this.osUpgradeCommand(ref, by, msg.osUpgrade);
+            }
+        }
+        catch (e) {
+            this.log.warn(`Command ${msg.cmd} of ${by} failed: ${e.message}`);
+            await this.reply(ref, 'error', e.message);
+        }
+        finally {
+            this.commandRunning = false;
+        }
+    }
+    /** Start, stop or restart an instance on this host, the same way admin does it */
+    async instanceCommand(ref, by, req) {
+        const id = req?.id;
+        const action = req?.action;
+        const objId = `system.adapter.${id}`;
+        const obj = typeof id === 'string' && /^[\w.-]+$/.test(id) ? await this.getForeignObjectAsync(objId) : null;
+        const refusal = (0, commands_1.instanceRefusal)(id, action, this.namespace, obj, this.host || '');
+        if (refusal || !req) {
+            await this.reply(ref, 'error', refusal || 'Instanz fehlt');
+            return;
+        }
+        this.log.info(`Instance ${req.id}: ${req.action} on request of ${by} (fleet management)`);
+        const own = req.id === this.namespace;
+        if (own) {
+            // a restart of this instance ends this process: answer first
+            await this.reply(ref, 'done', `${req.id} startet neu`);
+        }
+        await this.extendForeignObjectAsync(objId, req.action === 'restart' ? {} : { common: { enabled: req.action === 'start' } });
+        if (!own) {
+            await this.reply(ref, 'done', `${req.id} ${commands_1.ACTION_DONE[req.action]}`);
+            this.inventorySoon();
+        }
+    }
+    /** Upgrade OS packages through js-controller, only those it listed itself */
+    async osUpgradeCommand(ref, by, req) {
+        const host = `system.host.${this.host}`;
+        const hostObj = await this.getForeignObjectAsync(host);
+        if (!(0, commands_1.supportedCommands)(String(hostObj?.common?.installedVersion || '')).includes('osUpgrade')) {
+            await this.reply(ref, 'error', 'OS-Updates brauchen Linux und js-controller ab 6');
+            return;
+        }
+        const listed = (0, commands_1.osUpdatesFrom)(await this.getForeignStateAsync(`${host}.osPackageUpdates`), false)?.packages ?? [];
+        const { packages, unknown } = (0, commands_1.chooseOsPackages)(listed, req?.packages);
+        if (!packages.length || unknown.length) {
+            await this.reply(ref, 'error', unknown.length ? `Nicht als aktualisierbar gelistet: ${unknown.join(', ')}` : 'Keine Pakete angegeben');
+            return;
+        }
+        const names = packages.map(p => p.name).join(', ');
+        this.log.warn(`Upgrade of OS packages ${names} on request of ${by} (fleet management)`);
+        await this.reply(ref, 'running', `apt: ${names}`);
+        // js-controller runs apt (with sudo if it is not root) and answers when it is through
+        const answer = (await Promise.race([
+            this.sendToHostAsync(host, 'upgradeOsPackages', {
+                packages: packages.map(p => ({ name: p.name })),
+                restart: !!req?.restart,
+            }),
+            new Promise(resolve => {
+                this.timers.push(setTimeout(() => resolve({ error: 'Keine Antwort von js-controller nach 30 Minuten' }), 30 * 60_000));
+            }),
+        ]));
+        if (answer?.success) {
+            this.log.info(`OS packages upgraded: ${names}`);
+            await this.reply(ref, 'done', `${packages.length} ${packages.length === 1 ? 'Paket' : 'Pakete'} aktualisiert${req?.restart ? ', ioBroker startet neu' : ''}`);
+            this.inventorySoon();
+        }
+        else {
+            const error = answer?.error || 'js-controller meldet einen Fehler';
+            this.log.warn(`OS upgrade failed: ${error}`);
+            await this.reply(ref, 'error', error);
+        }
+    }
+    // ------------------------------------------------------------------ remote access
+    /** Kinds of remote access the owner allows in the instance settings */
+    allowedAccess() {
+        const kinds = [];
+        if (this.config.allowAdmin !== false) {
+            kinds.push('admin');
+        }
+        if (this.config.allowVis !== false) {
+            kinds.push('vis');
+        }
+        if (this.config.allowConsole === true && (0, console_1.findScript)()) {
+            kinds.push('console');
+        }
+        return kinds;
+    }
+    /** One shell for a stream of a console session, at most MAX_SHELLS at the same time */
+    openShell(t, stream) {
+        const running = this.shells.get(t.id) ?? 0;
+        if (running >= console_1.MAX_SHELLS) {
+            stream.end(Buffer.concat([
+                (0, tunnel_1.consoleMessage)(tunnel_1.CONSOLE.DATA, Buffer.from(`Höchstens ${console_1.MAX_SHELLS} Shells je Sitzung.\r\n`)),
+                (0, tunnel_1.consoleMessage)(tunnel_1.CONSOLE.EXIT, Buffer.from('zu viele Shells')),
+            ]));
+            return;
+        }
+        this.shells.set(t.id, running + 1);
+        void this.updateAccessStates();
+        (0, console_1.startShell)(stream, {
+            cwd: (0, node_path_1.join)(utils.controllerDir, '..', '..'),
+            log: this.log,
+            by: t.by,
+            onEnd: () => {
+                const n = (this.shells.get(t.id) ?? 1) - 1;
+                if (n > 0) {
+                    this.shells.set(t.id, n);
+                }
+                else {
+                    this.shells.delete(t.id);
+                }
+                if (!this.unloading) {
+                    void this.updateAccessStates();
+                }
+            },
+        });
+    }
+    /**
+     * Opens the tunnel of an access session, or refuses it with a reason the operator sees.
+     *
+     * @param t request of the server
+     * @param resumed the session was open before a restart of the agent
+     */
+    async openTunnel(t, resumed) {
+        if (this.tunnels.has(t.id) || t.expiresAt <= Date.now() || this.unloading) {
+            // repeated delivery of the job, or over
+            return;
+        }
+        if (!(0, remote_1.trustedTunnelUrl)(t.url, [this.config.enrollUrl, this.creds?.mqttUrl || ''])) {
+            this.log.warn(`Remote access: tunnel URL ${t.url} does not belong to the fleet server, ignored`);
+            return;
+        }
+        let refusal = null;
+        let target = null;
+        const isConsole = t.kind === 'console';
+        if (!this.allowedAccess().includes(t.kind)) {
+            refusal = !isConsole
+                ? `Fernzugriff auf ${remote_1.ACCESS_LABEL[t.kind]} ist am Gerät abgeschaltet`
+                : this.config.allowConsole === true
+                    ? 'Die Konsole braucht Linux mit script (util-linux)'
+                    : 'Die Konsole ist am Gerät nicht freigegeben';
+        }
+        else if (isConsole) {
+            if (this.tunnels.size >= 4) {
+                refusal = 'Zu viele gleichzeitige Fernzugriffe auf dem Gerät';
+            }
+        }
+        else {
+            // only an instance of this kind on this host, whatever the server asks for
+            target = (0, remote_1.chooseTarget)(await (0, remote_1.findTargets)(this, t.kind), t.instance);
+            if (!target) {
+                refusal = t.instance
+                    ? `Instanz ${t.instance} ist auf dem Gerät nicht aktiv`
+                    : `Keine aktive ${t.kind === 'admin' ? 'admin' : 'web'}-Instanz auf dem Gerät`;
+            }
+            else if (this.tunnels.size >= 4) {
+                refusal = 'Zu viele gleichzeitige Fernzugriffe auf dem Gerät';
+            }
+        }
+        const client = new remote_1.TunnelClient(t, {
+            target,
+            ...(isConsole && !refusal ? { handler: (stream) => this.openShell(t, stream) } : {}),
+            refusal,
+            ca: (0, transport_1.trustedCas)(this.creds?.ca || ''),
+            log: this.log,
+            onEnd: (c, reason) => {
+                if (this.tunnels.get(t.id) === c) {
+                    this.tunnels.delete(t.id);
+                    this.shells.delete(t.id);
+                    this.log.info(`Remote access to ${remote_1.ACCESS_LABEL[t.kind]} by ${t.by} ended (${reason})`);
+                }
+                if (!this.unloading) {
+                    void this.saveTunnels();
+                    void this.updateAccessStates();
+                }
+            },
+        });
+        if (refusal) {
+            this.log.warn(`Remote access to ${remote_1.ACCESS_LABEL[t.kind]} by ${t.by} refused: ${refusal}`);
+        }
+        else {
+            this.tunnels.set(t.id, client);
+            this.log.info(`Remote access to ${remote_1.ACCESS_LABEL[t.kind]}${target ? ` (${target.instance})` : ''} ${resumed ? 'resumed' : 'opened'} by ${t.by} until ${new Date(t.expiresAt).toLocaleTimeString()}: ${t.purpose}`);
+        }
+        client.start();
+        await this.saveTunnels();
+        await this.updateAccessStates();
+    }
+    async saveTunnels() {
+        await (0, util_1.writeJsonAtomic)((0, node_path_1.join)(this.dataDir, 'tunnels.json'), [...this.tunnels.values()].map(c => c.req));
+    }
+    /** " (2 Shells offen)" for a console */
+    shellText(t) {
+        if (t.kind !== 'console') {
+            return '';
+        }
+        const n = this.shells.get(t.id) ?? 0;
+        return n ? ` (${n} ${n === 1 ? 'Shell' : 'Shells'} offen)` : '';
+    }
+    /** Shows the owner who is connected right now, and why */
+    async updateAccessStates() {
+        const active = [...this.tunnels.values()].map(c => c.req);
+        await this.setState('info.remoteAccess', active.length > 0, true);
+        await this.setState('info.remoteAccessBy', active
+            .map(t => `${remote_1.ACCESS_LABEL[t.kind]}${t.instance ? ` (${t.instance})` : ''}${this.shellText(t)}: ${t.by}, ${t.purpose} (bis ${new Date(t.expiresAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`)
+            .join('; '), true);
+    }
+    // ------------------------------------------------------------------ inventory and heartbeat
+    async inventory() {
+        const inv = await (0, inventory_1.collectInventory)(this, {
+            agentVersion: this.version || '',
+            dataDir: this.dataDir,
+            lastBackup: this.persisted.lastBackup,
+        });
+        inv.uuid = this.uuid;
+        const comment = (0, protocol_1.normalizeComment)(this.config.comment);
+        if (comment) {
+            inv.comment = comment;
+        }
+        // also tells the server that this agent can open a tunnel at all
+        inv.remoteAccess = this.allowedAccess();
+        inv.accessTargets = {
+            admin: (0, remote_1.describeTargets)(await (0, remote_1.findTargets)(this, 'admin')),
+            vis: (0, remote_1.describeTargets)(await (0, remote_1.findTargets)(this, 'vis')),
+        };
+        if (inv.remoteAccess.includes('console')) {
+            inv.consoleUser = (0, console_1.consoleUser)();
+        }
+        inv.commands = (0, commands_1.supportedCommands)(inv.software.jsController);
+        if (inv.commands.includes('osUpgrade')) {
+            const updates = (0, commands_1.osUpdatesFrom)(await this.getForeignStateAsync(`system.host.${this.host}.osPackageUpdates`), (0, node_fs_1.existsSync)(commands_1.REBOOT_REQUIRED));
+            if (updates) {
+                inv.osUpdates = updates;
+            }
+        }
+        return inv;
+    }
+    async sendInventory(full) {
+        if (!this.transport?.connected) {
+            return;
+        }
+        const inv = await this.inventory();
+        const flat = (0, util_1.flatten)(inv);
+        if (full || !this.lastFlat) {
+            this.seq++;
+            await this.transport.publish('inventory', {
+                v: protocol_1.PROTOCOL_VERSION,
+                ts: Date.now(),
+                seq: this.seq,
+                type: 'full',
+                data: inv,
+            });
+        }
+        else {
+            const { set, unset } = (0, util_1.diffFlat)(this.lastFlat, flat);
+            if (!Object.keys(set).length && !unset.length) {
+                return;
+            }
+            this.seq++;
+            await this.transport.publish('inventory', {
+                v: protocol_1.PROTOCOL_VERSION,
+                ts: Date.now(),
+                seq: this.seq,
+                type: 'diff',
+                baseSeq: this.seq - 1,
+                set,
+                unset,
+            });
+        }
+        this.lastFlat = flat;
+    }
+    async heartbeat() {
+        const disk = await (0, inventory_1.diskInfo)(this.dataDir);
+        let signal = null;
+        if (this.config.signalStateId) {
+            const s = await this.getForeignStateAsync(this.config.signalStateId);
+            signal = typeof s?.val === 'number' ? s.val : null;
+        }
+        const msg = {
+            v: protocol_1.PROTOCOL_VERSION,
+            ts: Date.now(),
+            online: true,
+            agentVersion: this.version,
+            uptime: Math.round(node_os_1.default.uptime()),
+            load: Math.round(node_os_1.default.loadavg()[0] * 100) / 100,
+            memFree: node_os_1.default.freemem(),
+            diskFree: disk?.free,
+            temperature: (await (0, inventory_1.cpuTemperature)()) ?? undefined,
+            logErrors: this.errorsSinceHeartbeat,
+            jobState: this.jobs?.job?.state,
+            signal,
+            sdWrites: await (0, inventory_1.sdWrites)(),
+        };
+        this.errorsSinceHeartbeat = 0;
+        await this.transport?.publish('state', msg);
+    }
+    onLog(msg) {
+        if (msg.severity !== 'error' || msg.from?.startsWith(`${this.namespace}`)) {
+            return;
+        }
+        this.errorsSinceHeartbeat++;
+        this.errorLog.push({ ts: Date.now(), from: msg.from, message: String(msg.message) });
+        if (this.errorLog.length > 500) {
+            this.errorLog.splice(0, this.errorLog.length - 500);
+        }
+    }
+    async instancesOf(adapter) {
+        const res = await this.getObjectViewAsync('system', 'instance', {
+            startkey: `system.adapter.${adapter}.`,
+            endkey: `system.adapter.${adapter}.香`,
+        });
+        const list = [];
+        for (const row of res.rows) {
+            const obj = row.value;
+            if (!obj?.common.enabled || obj.common.host !== this.host) {
+                continue;
+            }
+            // scheduled instances are not running permanently
+            if (obj.common.mode !== 'daemon') {
+                continue;
+            }
+            const alive = await this.getForeignStateAsync(`${obj._id}.alive`);
+            list.push({ id: obj._id.replace('system.adapter.', ''), alive: !!alive?.val });
+        }
+        return list;
+    }
+    // ------------------------------------------------------------------ reconciliation
+    async report(state, detail, steps) {
+        const d = this.desired;
+        if (!d?.profile) {
+            return;
+        }
+        const msg = {
+            v: protocol_1.PROTOCOL_VERSION,
+            ts: Date.now(),
+            profileId: d.profile.id,
+            profileHash: d.profile.hash,
+            retry: d.retry,
+            state,
+            detail,
+            steps,
+        };
+        this.persisted.lastResult = msg;
+        await this.savePersisted();
+        await this.setState('job.state', state, true);
+        await this.setState('job.detail', detail, true);
+        await this.transport?.publish('result', msg);
+    }
+    async reportJob(job) {
+        const msg = {
+            v: protocol_1.PROTOCOL_VERSION,
+            ts: Date.now(),
+            profileId: job.profileId,
+            profileHash: job.profileHash,
+            retry: job.retry,
+            state: job.state,
+            detail: job.detail,
+            steps: job.steps,
+        };
+        this.persisted.lastResult = msg;
+        await this.savePersisted();
+        await this.setState('job.state', job.state, true);
+        await this.setState('job.detail', job.detail, true);
+        await this.setState('job.steps', JSON.stringify(job.steps), true);
+        await this.transport?.publish('result', msg);
+    }
+    async onJobFinished(job, result) {
+        if (result !== 'waiting') {
+            this.persisted.results[job.key] = result;
+        }
+        const backup = job.steps.find(s => s.action === 'backup' && s.status === 'ok');
+        if (backup?.detail) {
+            this.persisted.lastBackup = { ts: backup.ts || Date.now(), file: backup.detail, size: 0 };
+        }
+        await this.savePersisted();
+        this.log.info(`Job ${job.profileName}: ${result} (${job.detail})`);
+        if (result === 'done') {
+            await this.notify('updated', `Das System wurde auf den Stand ${job.profileName} gebracht.`);
+        }
+        await this.sendInventory(false);
+        await this.updateInfoStates();
+        // the desired state may have changed while the job was running
+        setTimeout(() => void this.reconcile(), 1000);
+    }
+    /** Converges on the desired state if possible. Never runs two jobs at once. */
+    async reconcile() {
+        if (this.reconciling || this.unloading || !this.jobs || this.jobs.isActive()) {
+            return;
+        }
+        this.reconciling = true;
+        try {
+            await this.reconcileInner();
+        }
+        catch (e) {
+            this.log.error(`Reconcile: ${e.stack || e.message}`);
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+    async reconcileInner() {
+        const d = this.desired;
+        if (!d?.profile) {
+            return;
+        }
+        const inv = await this.inventory();
+        const installed = (0, inventory_1.installedVersions)(inv);
+        const key = `${d.profile.hash}:${d.retry}`;
+        // a package with the version number of what is installed: once per job, never in a loop
+        const from = this.persisted.results[key] === 'done'
+            ? undefined
+            : Object.fromEntries(Object.entries(inv.software.adapters).map(([n, a]) => [n, a.installedFrom]));
+        const plan = (0, planner_1.computePlan)(d, installed, this.name, from);
+        await this.setState('info.onTarget', plan.length === 0, true);
+        if (d.mode === 'self') {
+            // self-managed: no automatic rollout, only a hint about the new state
+            if (plan.length && !this.persisted.notified[`update:${d.profile.hash}`]) {
+                this.persisted.notified[`update:${d.profile.hash}`] = Date.now();
+                await this.savePersisted();
+                await this.notify('updateAvailable', `Neuer Softwarestand ${d.profile.name} verfügbar (${plan.length} Änderungen). Die Anlage ist eigenverantwortlich und wird nicht automatisch aktualisiert.`);
+            }
+            return;
+        }
+        const foreign = (0, planner_1.foreignAdapters)(d, installed);
+        if (foreign.length) {
+            // own installations: do not touch anything; the server switches the mode and informs the dealer
+            const key = `foreign:${foreign.join(',')}`;
+            if (!this.persisted.notified[key]) {
+                this.persisted.notified[key] = Date.now();
+                await this.savePersisted();
+                await this.notify('modeChanged', `Selbst installierte Adapter erkannt (${foreign.join(', ')}). Die Anlage erhält keine automatischen Updates mehr, bis sie in den verwalteten Modus zurückgeführt wird.`);
+            }
+            await this.setState('info.status', `Eigeninstallation erkannt: ${foreign.join(', ')}`, true);
+            return;
+        }
+        if (this.persisted.results[key] === 'blocked') {
+            return;
+        }
+        if (!plan.length) {
+            if (this.persisted.results[key] !== 'done') {
+                this.persisted.results[key] = 'done';
+                await this.report('done', 'Bereits auf Sollstand');
+            }
+            return;
+        }
+        // drift after an earlier success (e.g. manual change): converge again
+        delete this.persisted.results[key];
+        const pf = await (0, preflight_1.preflight)({
+            now: new Date(),
+            halted: !!this.control?.halt,
+            haltReason: this.control?.reason,
+            window: {
+                start: this.config.windowStart || '02:00',
+                end: this.config.windowEnd || '05:00',
+                ignore: !!this.config.ignoreWindow,
+            },
+            conditions: (this.config.conditions || []).filter(c => c?.stateId),
+            readState: async (id) => (await this.getForeignStateAsync(id))?.val ?? undefined,
+            diskPath: this.dataDir,
+            minFreeMb: this.config.minFreeMb || 1024,
+            dependencyErrors: (0, planner_1.checkDependencies)(d, installed, {
+                jsController: inv.software.jsController,
+                node: process.version,
+            }),
+        });
+        if (!pf.ok) {
+            if (pf.kind === 'block') {
+                this.persisted.results[key] = 'blocked';
+                await this.report('blocked', pf.reason, plan);
+            }
+            else if (pf.reason !== this.lastWaitReason) {
+                this.lastWaitReason = pf.reason;
+                await this.report('waiting', pf.reason, plan);
+            }
+            return;
+        }
+        // packages of the server for single assets: loaded before anything changes
+        const files = {};
+        for (const [adapter, tarball] of Object.entries((0, packages_1.packagesOf)(d, plan))) {
+            try {
+                files[adapter] = await (0, packages_1.ensurePackage)((0, node_path_1.join)(this.dataDir, 'packages'), tarball, {
+                    serverUrls: [this.config.enrollUrl, this.creds?.mqttUrl || ''],
+                    ca: (0, transport_1.trustedCas)(this.creds?.ca || ''),
+                });
+            }
+            catch (e) {
+                const reason = `Paket für ${adapter} nicht ladbar: ${e.message}`;
+                this.log.warn(reason);
+                if (reason !== this.lastWaitReason) {
+                    this.lastWaitReason = reason;
+                    await this.report('waiting', reason, plan);
+                }
+                return;
+            }
+        }
+        this.lastWaitReason = '';
+        this.log.info(`Starting job for ${d.profile.name}: ${plan.map(s => `${s.action} ${s.adapter}`).join(', ')}`);
+        await this.report('preflight', `${plan.length} Schritte geplant, Vorprüfung bestanden`, plan);
+        await this.jobs.start(d, plan, this.config.backupBeforeUpdate !== false, files);
+    }
+    // ------------------------------------------------------------------ states, notifications
+    async updateInfoStates() {
+        await this.setState('info.deviceId', this.creds?.deviceId || '', true);
+        await this.setState('info.assetId', this.creds?.assetId || '', true);
+        await this.setState('info.mode', this.desired?.mode || '', true);
+        await this.setState('info.profile', this.desired?.profile?.name || '', true);
+    }
+    async notify(category, message) {
+        try {
+            await this.registerNotification('bee', category, message);
+        }
+        catch (e) {
+            this.log.debug(`Notification not possible: ${e.message}`);
+        }
+    }
+    async onStateChange(id, state) {
+        if (!state || state.ack) {
+            return;
+        }
+        if (id === `${this.namespace}.control.refresh`) {
+            await this.sendInventory(true);
+            await this.setState('control.refresh', false, true);
+        }
+        else if (id === `${this.namespace}.control.check`) {
+            this.lastWaitReason = '';
+            await this.reconcile();
+            await this.setState('control.check', false, true);
+        }
+    }
+}
+if (require.main !== module) {
+    module.exports = (options) => new BeeAdapter(options);
+}
+else {
+    (() => new BeeAdapter())();
+}
+//# sourceMappingURL=main.js.map