@nubisco/openbridge 0.29.0

package/dist/daemon.js

@@ -0,0 +1,636 @@
+import { resolve, join } from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import os from 'os';
+import { PluginRegistry, PluginLifecycle, loadPluginsFromDirectory, loadPlugin } from '@nubisco/openbridge-core';
+import { Logger } from '@nubisco/openbridge-logger';
+import { loadConfig, defaultConfigPath } from '@nubisco/openbridge-config';
+import { createServer } from './server.js';
+import { DeviceSeries, DEFAULT_TIERS } from './timeseries.js';
+import { HomeKitVisibility } from './homekit-visibility.js';
+import { HomeKitServiceTypes } from './homekit-service-type.js';
+import { HomebridgeAPI, loadHomebridgePlugin, serializeAccessory } from '@nubisco/openbridge-compatibility-homebridge';
+const log = Logger.create('system');
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const req = createRequire(import.meta.url);
+// Canonical storage root: every file OpenBridge owns lives here
+export const OPENBRIDGE_HOME = resolve(os.homedir(), '.openbridge');
+export const OB_PLUGINS_DIR = join(OPENBRIDGE_HOME, 'plugins', 'openbridge');
+export const HB_PLUGINS_DIR = join(OPENBRIDGE_HOME, 'plugins', 'homebridge');
+export const METRICS_DIR = join(OPENBRIDGE_HOME, 'metrics');
+/** Metric sampling cadence, matched to the finest storage tier. */
+const SAMPLE_INTERVAL_MS = DEFAULT_TIERS[0].interval * 1000;
+export class Daemon {
+    registry = new PluginRegistry();
+    lifecycle = new PluginLifecycle(this.registry);
+    loadedPlugins = [];
+    /** npm package names of HB plugins already running via config.platforms: skip in discovery */
+    knownHbPackageNames = new Set();
+    controls = new Map();
+    restrictedControls = new Set();
+    /** Main HAP bridge and hap-nodejs module, shared with native plugins */
+    hapBridgeRef = null;
+    /** Time-series store per device, for devices that declare metrics */
+    metricSeries = new Map();
+    /** Per-service HomeKit type overrides, applied at the bridge */
+    homekitServiceTypes = new HomeKitServiceTypes(join(OPENBRIDGE_HOME, 'homekit-service-types.json'));
+    /** Per-accessory HomeKit visibility, enforced at the bridge */
+    homekitVisibility = new HomeKitVisibility(join(OPENBRIDGE_HOME, 'homekit-hidden.json'), null, this.homekitServiceTypes);
+    /**
+     * Find the HAP accessory a native plugin published for one of its devices.
+     *
+     * Native plugins add accessories straight to the bridge, so they never enter
+     * HomebridgeAPI's map and /api/accessories cannot see them. Every accessory
+     * does pass through the visibility proxy though, so it holds the full set.
+     *
+     * The link is by convention: plugins seed the accessory UUID from the device
+     * id (`hap.uuid.generate(deviceId)`), which is what the SDK's own accessory
+     * helpers do. A plugin that seeds it differently simply resolves to null and
+     * the UI omits the HomeKit controls, rather than showing the wrong ones.
+     */
+    resolveNativeAccessory(deviceId) {
+        const accessory = this.findNativeAccessory(deviceId);
+        return accessory ? serializeAccessory(accessory) : null;
+    }
+    /** As above, but only the UUID: cheap enough to call for every device. */
+    nativeAccessoryUuid(deviceId) {
+        return this.findNativeAccessory(deviceId)?.UUID ?? null;
+    }
+    findNativeAccessory(deviceId) {
+        const hap = this.hapBridgeRef?.hap;
+        if (!hap?.uuid?.generate)
+            return null;
+        return this.homekitVisibility.find(hap.uuid.generate(deviceId));
+    }
+    async start(options = {}) {
+        const configPath = options.configPath ?? defaultConfigPath();
+        log.info('Starting OpenBridge daemon...');
+        log.info(`Config: ${configPath}`);
+        // Prevent unhandled errors from silently killing plugin event loops
+        process.on('unhandledRejection', (reason) => {
+            log.error(`Unhandled promise rejection (plugin may need restart): ${reason}`);
+        });
+        process.on('uncaughtException', (err) => {
+            log.error(`Uncaught exception: ${err.message}\n${err.stack}`);
+            // Only exit on truly fatal errors (e.g. out of memory)
+            if (err.message?.includes('out of memory') || err.message?.includes('ENOMEM')) {
+                process.exit(1);
+            }
+        });
+        const config = await loadConfig(configPath);
+        Logger.setLevel(config.bridge.logLevel);
+        const port = options.port ?? config.bridge.port;
+        // Ensure canonical storage dirs exist
+        mkdirSync(OB_PLUGINS_DIR, { recursive: true });
+        mkdirSync(HB_PLUGINS_DIR, { recursive: true });
+        log.info(`Bridge name: ${config.bridge.name}`);
+        log.info(`HTTP API port: ${port}`);
+        log.info(`OpenBridge home: ${OPENBRIDGE_HOME}`);
+        // ── HAP Bridge (HomeKit) ──────────────────────────────────────────────────
+        // The default bridge is ALWAYS created: it advertises all accessories
+        // from both native plugins and Homebridge-compatible platforms.
+        let hapBridge = null;
+        let homebridgeAPI = null;
+        let hapInfo = null;
+        // Load disabled plugins list early: applies to both Homebridge platforms and native plugins
+        let disabledPlugins = [];
+        try {
+            const rawCfg = JSON.parse(readFileSync(configPath, 'utf8'));
+            disabledPlugins = (rawCfg.disabledPlugins ?? []);
+        }
+        catch {
+            /* config file may not exist yet */
+        }
+        try {
+            // Load hap-nodejs: look in daemon or workspace node_modules
+            const hapCandidates = [
+                resolve(__dirname, '../node_modules/hap-nodejs'), // apps/daemon/node_modules (from dist/)
+                resolve(__dirname, '../../node_modules/hap-nodejs'), // apps/node_modules
+                resolve(__dirname, '../../../node_modules/hap-nodejs'), // workspace root node_modules
+                resolve(process.cwd(), 'node_modules/hap-nodejs'),
+            ];
+            let hapNodeJs = null;
+            for (const candidate of hapCandidates) {
+                try {
+                    hapNodeJs = req(candidate);
+                    log.info(`Loaded hap-nodejs from ${candidate}`);
+                    break;
+                }
+                catch {
+                    /* try next */
+                }
+            }
+            if (!hapNodeJs) {
+                throw new Error('hap-nodejs not found. Run: pnpm add hap-nodejs --filter @nubisco/openbridge-daemon');
+            }
+            // Init HAP storage
+            const storagePath = resolve(process.env.HOME ?? '.', '.openbridge', 'hap-storage');
+            hapNodeJs.HAPStorage.setCustomStoragePath(storagePath);
+            // Create the bridge
+            hapBridge = new hapNodeJs.Bridge(config.bridge.name, hapNodeJs.uuid.generate(config.bridge.name));
+            hapBridge
+                .getService(hapNodeJs.Service.AccessoryInformation)
+                .setCharacteristic(hapNodeJs.Characteristic.Manufacturer, 'Nubisco')
+                .setCharacteristic(hapNodeJs.Characteristic.Model, 'OpenBridge')
+                .setCharacteristic(hapNodeJs.Characteristic.SoftwareRevision, '0.1.0');
+            // Wrap the bridge so per-accessory HomeKit visibility is enforced in one
+            // place. Both plugin kinds reach HomeKit through addBridgedAccessory, so
+            // wrapping here covers native and Homebridge-compat plugins alike, and
+            // works for plugins that offer no exposeToHomeKit setting of their own.
+            this.homekitServiceTypes.setHap(hapNodeJs);
+            const visibleBridge = this.homekitVisibility.wrapBridge(hapBridge);
+            // Store reference so native plugins can add accessories to the main bridge
+            this.hapBridgeRef = { bridge: visibleBridge, hap: hapNodeJs };
+            // Create the HomebridgeAPI shim
+            homebridgeAPI = new HomebridgeAPI(hapNodeJs, visibleBridge);
+            // Restore cached accessories so they survive container restarts.
+            // Must happen before launchPlatforms() so configureAccessory() can re-adopt them.
+            homebridgeAPI.loadCachedAccessories();
+            // ── Load Homebridge-compatible plugins ────────────────────────────────
+            // Legacy: config.platforms[] with explicit file paths (backward compat)
+            if (config.platforms && config.platforms.length > 0) {
+                const enabledPlatforms = config.platforms.filter((p) => !disabledPlugins.includes(p.platform));
+                const skippedPlatforms = config.platforms.filter((p) => disabledPlugins.includes(p.platform));
+                if (enabledPlatforms.length > 0) {
+                    log.info(`Loading ${enabledPlatforms.length} legacy platform(s) from config.platforms...`);
+                }
+                for (const p of skippedPlatforms) {
+                    log.info(`Skipping disabled platform: ${p.platform}`);
+                }
+                for (const platformConfig of enabledPlatforms) {
+                    if (!platformConfig.plugin) {
+                        log.warn(`Platform "${platformConfig.platform}" has no "plugin" path, skipping`);
+                        continue;
+                    }
+                    const pluginPath = resolve(platformConfig.plugin);
+                    log.info(`Loading Homebridge plugin: ${pluginPath}`);
+                    try {
+                        const pkgPath = pluginPath
+                            .replace(/\/dist\/.*$/, '/package.json')
+                            .replace(/\/index\.js$/, '/../package.json');
+                        try {
+                            const pkg = req(pkgPath);
+                            platformConfig.version = pkg.version;
+                            if (pkg.name)
+                                this.knownHbPackageNames.add(pkg.name);
+                        }
+                        catch {
+                            /* version stays unknown */
+                        }
+                        const pluginFn = loadHomebridgePlugin(pluginPath);
+                        pluginFn(homebridgeAPI);
+                        log.info(`Registered platform: ${platformConfig.platform}`);
+                    }
+                    catch (err) {
+                        log.error(`Failed to load plugin ${platformConfig.plugin}: ${err}`);
+                    }
+                }
+                const platformLogger = Logger.create('hap');
+                await homebridgeAPI.launchPlatforms(enabledPlatforms, platformLogger, this.registry);
+            }
+            // Publish the HAP bridge
+            const hapPort = config.bridge.hapPort ?? 51829;
+            const pincode = config.bridge.pincode ?? '031-45-154';
+            const username = config.bridge.username ?? generateUsername(config.bridge.name);
+            hapBridge.publish({
+                username,
+                pincode,
+                port: hapPort,
+                category: hapNodeJs.Categories.BRIDGE,
+            });
+            hapInfo = { setupURI: hapBridge.setupURI(), pincode };
+            log.info(`HAP bridge published: PIN: ${pincode}`);
+            printPairingInfo(hapInfo.setupURI, pincode);
+        }
+        catch (err) {
+            log.error(`HAP bridge setup failed: ${err}`);
+        }
+        // ── OpenBridge native plugins ─────────────────────────────────────────────
+        log.info(`Native plugins dir: ${OB_PLUGINS_DIR}`);
+        const plugins = await loadPluginsFromDirectory(OB_PLUGINS_DIR);
+        log.info(`Loaded ${plugins.length} native plugin(s)`);
+        for (const plugin of plugins) {
+            this.registry.register(plugin);
+        }
+        this.loadedPlugins = plugins;
+        // Mark disabled native plugins
+        for (const disabledId of disabledPlugins) {
+            const entry = this.registry.get(disabledId);
+            if (entry) {
+                entry.instance.disabled = true;
+                this.registry.updateStatus(disabledId, 'stopped');
+                log.debug(`Plugin marked as disabled: ${disabledId}`);
+            }
+        }
+        // Only start plugins that are not disabled
+        const enabledPlugins = plugins.filter((p) => !disabledPlugins.includes(p.manifest.name));
+        await this.lifecycle.startAll(enabledPlugins, (plugin) => this.makeContext(plugin, config));
+        await this.discoverMarketplacePlugins(config, disabledPlugins, homebridgeAPI);
+        // Every platform that is going to register has now done so, so anything
+        // left in the accessory cache belonging to an unknown platform came from a
+        // plugin that has since been uninstalled *or been disabled* (a disabled one
+        // is deliberately left unregistered above). Those accessories would
+        // otherwise stay on the bridge forever with nothing behind them.
+        if (homebridgeAPI) {
+            const orphans = homebridgeAPI.pruneOrphanedAccessories();
+            if (orphans.length > 0) {
+                log.info(`Removed ${orphans.length} orphaned accessory(ies) from inactive plugins: ${orphans.join(', ')}`);
+            }
+        }
+        // ── HTTP server ───────────────────────────────────────────────────────────
+        const localPluginSources = config.localPluginSources ?? [];
+        const server = await createServer(this.registry, homebridgeAPI, hapInfo, localPluginSources, this.knownHbPackageNames, this.controls, this.restrictedControls, this.homekitVisibility, this.homekitServiceTypes, (deviceId) => this.resolveNativeAccessory(deviceId), (deviceId) => this.nativeAccessoryUuid(deviceId));
+        await server.listen({ port, host: '0.0.0.0' });
+        // ── Energy history sampling ───────────────────────────────────────────────
+        setInterval(() => {
+            this.sampleEnergyHistory();
+        }, 5 * 60 * 1000);
+        // Also sample immediately on startup (after a short delay for devices to connect)
+        setTimeout(() => this.sampleEnergyHistory(), 30_000);
+        // ── Metric history sampling ───────────────────────────────────────────────
+        // Devices that declare metrics are recorded at the finest tier's cadence.
+        // The store samples on its own timer rather than having plugins push every
+        // reading, so a fast-polling plugin cannot flood the disk and storage stays
+        // independent of plugin behaviour.
+        setInterval(() => this.sampleMetrics(), SAMPLE_INTERVAL_MS);
+        setTimeout(() => this.sampleMetrics(), 15_000);
+        // Rolling up is cheap but pointless to run often: the finest rollup window
+        // is a minute, so once a minute is enough to keep every tier current.
+        setInterval(() => this.rollupMetrics(), 60_000);
+        // ── Platform health watchdog ─────────────────────────────────────────────
+        // Monitors Homebridge-compatible platforms and restarts them if they enter
+        // error status. Checks every 60 seconds, uses exponential backoff per platform.
+        if (homebridgeAPI) {
+            const watchdogInterval = 60_000;
+            const pendingRestarts = new Map();
+            setInterval(() => {
+                for (const instance of this.registry.getAll()) {
+                    if (instance.source !== 'homebridge')
+                        continue;
+                    if (instance.disabled)
+                        continue;
+                    const name = instance.platformName ?? instance.id;
+                    if (instance.status === 'error' && !pendingRestarts.has(name)) {
+                        const backoff = homebridgeAPI.getRestartBackoff(name);
+                        log.warn(`Platform "${name}" is in error state, scheduling restart in ${Math.round(backoff / 1000)}s`);
+                        const timer = setTimeout(async () => {
+                            pendingRestarts.delete(name);
+                            const ok = await homebridgeAPI.restartPlatform(name);
+                            if (!ok) {
+                                log.error(`Platform "${name}" restart failed, will retry with longer backoff`);
+                            }
+                        }, backoff);
+                        pendingRestarts.set(name, timer);
+                    }
+                }
+            }, watchdogInterval);
+        }
+        log.info(`OpenBridge running at http://localhost:${port}`);
+        // ── Graceful shutdown ─────────────────────────────────────────────────────
+        const shutdown = async () => {
+            log.info('Shutting down...');
+            hapBridge?.unpublish();
+            await this.lifecycle.stopAll(this.loadedPlugins, (plugin) => this.makeContext(plugin, config));
+            await server.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    async discoverMarketplacePlugins(config, disabledPlugins, homebridgeAPI) {
+        const pluginsRoot = HB_PLUGINS_DIR;
+        const manifestPath = join(pluginsRoot, 'package.json');
+        if (!existsSync(manifestPath))
+            return;
+        let topLevel;
+        try {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            topLevel = manifest.dependencies ?? {};
+        }
+        catch {
+            return;
+        }
+        for (const pkgName of Object.keys(topLevel)) {
+            if (this.registry.get(pkgName)) {
+                log.debug(`Marketplace: skipping ${pkgName} (already registered)`);
+                continue;
+            }
+            if (this.knownHbPackageNames.has(pkgName)) {
+                log.debug(`Marketplace: skipping ${pkgName} (already loaded as HB platform)`);
+                continue;
+            }
+            const pkgJsonPath = join(pluginsRoot, 'node_modules', pkgName, 'package.json');
+            if (!existsSync(pkgJsonPath)) {
+                log.debug(`Marketplace: skipping ${pkgName} (package.json not found)`);
+                continue;
+            }
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+                const name = pkg.name ?? pkgName;
+                const isNative = (Array.isArray(pkg.keywords) && pkg.keywords.includes('openbridge-plugin')) || pkg.openbridge != null;
+                const isHb = name.startsWith('homebridge-') || (Array.isArray(pkg.keywords) && pkg.keywords.includes('homebridge-plugin'));
+                // Native OpenBridge plugins: load via the plugin loader and start them
+                if (isNative) {
+                    // Ensure the plugin can resolve peer dependencies (like hap-nodejs) from the daemon's node_modules
+                    const daemonModules = resolve(__dirname, '../node_modules');
+                    if (!process.env.NODE_PATH?.includes(daemonModules)) {
+                        process.env.NODE_PATH = process.env.NODE_PATH ? `${process.env.NODE_PATH}:${daemonModules}` : daemonModules;
+                        req('module').Module._initPaths();
+                    }
+                    const pluginDir = join(pluginsRoot, 'node_modules', pkgName);
+                    const candidates = [join(pluginDir, 'dist', 'index.js'), join(pluginDir, 'index.js')];
+                    let loaded = false;
+                    for (const candidate of candidates) {
+                        if (existsSync(candidate)) {
+                            try {
+                                const plugin = await loadPlugin(candidate);
+                                this.registry.register(plugin);
+                                this.loadedPlugins.push(plugin);
+                                // Check if disabled
+                                if (!disabledPlugins.includes(name)) {
+                                    await this.lifecycle.startAll([plugin], (p) => this.makeContext(p, config));
+                                }
+                                else {
+                                    const entry = this.registry.get(name);
+                                    if (entry)
+                                        entry.instance.disabled = true;
+                                    this.registry.updateStatus(name, 'stopped');
+                                }
+                                log.info(`Loaded native plugin from marketplace: ${name} v${pkg.version ?? '?'}`);
+                                loaded = true;
+                                break;
+                            }
+                            catch (err) {
+                                log.error(`Failed to load native plugin ${name}: ${err}`);
+                            }
+                        }
+                    }
+                    if (loaded)
+                        continue;
+                }
+                // Homebridge-compatible plugins: auto-load if configured in config.plugins
+                // Set when the plugin turns out to be disabled under its platform name,
+                // which is only knowable after the module has registered itself.
+                let disabledByPlatformName = false;
+                if (isHb && homebridgeAPI) {
+                    const pluginEntry = config.plugins.find((p) => p.name === name);
+                    const pluginDir = join(pluginsRoot, 'node_modules', pkgName);
+                    const mainFile = join(pluginDir, pkg.main ?? 'dist/index.js');
+                    if (existsSync(mainFile) && !disabledPlugins.includes(name)) {
+                        try {
+                            this.knownHbPackageNames.add(name);
+                            const regCountBefore = homebridgeAPI._platformRegistrations?.length ?? 0;
+                            const pluginFn = loadHomebridgePlugin(mainFile);
+                            pluginFn(homebridgeAPI);
+                            // Get the platform name from the plugin's registerPlatform() call
+                            const regs = homebridgeAPI._platformRegistrations ?? [];
+                            const newReg = regs[regs.length - 1];
+                            const platformName = newReg && regs.length > regCountBefore
+                                ? newReg.platformName
+                                : (pluginEntry?.config?.platform ?? name);
+                            // Disable entries written before the identifier was canonicalised
+                            // hold the platform name ("ShellyDS9") rather than the package
+                            // name, so honour both. Checked here rather than above because
+                            // the platform name only exists once the module has registered.
+                            if (disabledPlugins.includes(platformName)) {
+                                log.info(`Skipping disabled Homebridge plugin: ${name} (platform ${platformName})`);
+                                disabledByPlatformName = true;
+                                // Undo the registration the module just made. Learning the
+                                // platform name requires loading the plugin, but leaving it
+                                // registered would make pruneOrphanedAccessories() treat the
+                                // platform as installed and spare its cached accessories,
+                                // which then sit on the bridge as inert "Default-Manufacturer"
+                                // entries with no plugin behind them to drive or control them.
+                                const registrations = homebridgeAPI._platformRegistrations;
+                                if (Array.isArray(registrations))
+                                    registrations.length = regCountBefore;
+                                // Falls through to the pseudo-plugin registration below so the
+                                // plugin still appears in the UI and can be re-enabled.
+                            }
+                            else {
+                                const pluginConfig = pluginEntry?.config ?? {};
+                                const platformConfig = {
+                                    platform: platformName,
+                                    plugin: mainFile,
+                                    ...pluginConfig,
+                                };
+                                const platformLogger = Logger.create('hap');
+                                await homebridgeAPI.launchPlatforms([platformConfig], platformLogger, this.registry);
+                                // launchPlatforms registers the instance under the platform name,
+                                // which is all it knows. Record the package name too: this
+                                // plugin's config lives in config.plugins[] keyed by it, and
+                                // without this the UI has no way back to that entry.
+                                const launched = this.registry.get(platformName);
+                                if (launched)
+                                    launched.instance.packageName = name;
+                                log.info(`Loaded Homebridge plugin from marketplace: ${name} v${pkg.version ?? '?'}`);
+                                continue;
+                            }
+                        }
+                        catch (err) {
+                            log.error(`Failed to load Homebridge plugin ${name}: ${err}`);
+                        }
+                    }
+                }
+                // Unconfigured or failed plugins: register as pseudo-plugin (stopped)
+                const pseudoPlugin = {
+                    manifest: {
+                        name,
+                        version: pkg.version ?? '?.?.?',
+                        description: pkg.description ?? '',
+                        author: typeof pkg.author === 'string' ? pkg.author : (pkg.author?.name ?? ''),
+                    },
+                };
+                const instance = this.registry.register(pseudoPlugin);
+                if (isHb)
+                    instance.source = 'homebridge';
+                instance.packageName = name;
+                // Without this the UI's Disabled switch reads as off for a plugin the
+                // daemon deliberately did not start.
+                if (disabledPlugins.includes(name) || disabledByPlatformName)
+                    instance.disabled = true;
+                this.registry.updateStatus(name, 'stopped');
+                log.info(instance.disabled
+                    ? `Discovered marketplace plugin: ${name} v${pkg.version ?? '?'} (disabled)`
+                    : `Discovered marketplace plugin: ${name} v${pkg.version ?? '?'} (not yet configured)`);
+            }
+            catch (err) {
+                log.warn(`Marketplace discovery: skipped ${pkgName}: ${err}`);
+            }
+        }
+    }
+    makeContext(plugin, config) {
+        const pluginConfig = config.plugins.find((p) => p.name === plugin.manifest.name)?.config ?? {};
+        const registry = this.registry;
+        const controls = this.controls;
+        const restrictedControls = this.restrictedControls;
+        return {
+            config: pluginConfig,
+            log: Logger.create(plugin.manifest.name),
+            reportTelemetry(deviceId, data) {
+                const entry = registry.get(plugin.manifest.name);
+                if (!entry)
+                    return;
+                if (!entry.instance.telemetry)
+                    entry.instance.telemetry = {};
+                entry.instance.telemetry[deviceId] = { ...data, _updatedAt: new Date().toISOString() };
+            },
+            registerDevice(device) {
+                const entry = registry.get(plugin.manifest.name);
+                if (!entry)
+                    return;
+                if (!entry.instance.devices)
+                    entry.instance.devices = {};
+                entry.instance.devices[device.id] = { ...device, pluginId: plugin.manifest.name };
+            },
+            registerControl(deviceId, controlId, handler) {
+                controls.set(`${deviceId}::${controlId}`, handler);
+            },
+            registerHapBridge(info) {
+                const entry = registry.get(plugin.manifest.name);
+                if (!entry) {
+                    log.warn(`registerHapBridge: plugin ${plugin.manifest.name} not found in registry`);
+                    return;
+                }
+                entry.instance.hapBridge = info;
+                log.info(`Plugin ${plugin.manifest.name} registered HAP bridge on port ${info.port} (PIN: ${info.pincode})`);
+            },
+            restrictControl(deviceId, controlId) {
+                restrictedControls.add(`${deviceId}::${controlId}`);
+                log.info(`Control restricted: ${deviceId}::${controlId}`);
+            },
+            getHapBridge: () => this.hapBridgeRef,
+        };
+    }
+    /**
+     * Look up (and cache) the series for a device that declares metrics.
+     *
+     * Returns null when the device declares none, which is the signal that it has
+     * live telemetry but nothing worth storing.
+     */
+    seriesFor(device) {
+        if (!device.metrics || device.metrics.length === 0)
+            return null;
+        const cached = this.metricSeries.get(device.id);
+        if (cached)
+            return cached;
+        const series = new DeviceSeries(join(OPENBRIDGE_HOME, 'metrics'), device.id, device.metrics);
+        this.metricSeries.set(device.id, series);
+        return series;
+    }
+    /** Record one sample per metric-declaring device from its latest telemetry. */
+    sampleMetrics() {
+        const t = Math.floor(Date.now() / 1000);
+        for (const instance of this.registry.getAll()) {
+            if (!instance.devices)
+                continue;
+            for (const device of Object.values(instance.devices)) {
+                const series = this.seriesFor(device);
+                if (!series)
+                    continue;
+                const telemetry = instance.telemetry?.[device.id];
+                if (!telemetry)
+                    continue;
+                const values = {};
+                let any = false;
+                for (const metric of device.metrics ?? []) {
+                    const raw = telemetry[metric.key];
+                    if (raw === undefined || raw === null)
+                        continue;
+                    const value = Number(raw);
+                    if (!Number.isFinite(value))
+                        continue;
+                    values[metric.key] = value;
+                    any = true;
+                }
+                // A device that is offline reports nothing; storing a row of zeros
+                // would draw a phantom dip rather than a gap.
+                if (!any)
+                    continue;
+                try {
+                    series.append({ t, values });
+                }
+                catch (err) {
+                    log.warn(`Failed to record metrics for ${device.id}: ${err}`);
+                }
+            }
+        }
+    }
+    /** Roll finished windows into coarser tiers and drop expired records. */
+    rollupMetrics() {
+        for (const series of this.metricSeries.values()) {
+            try {
+                series.rollup();
+            }
+            catch (err) {
+                log.warn(`Failed to roll up metrics for ${series.deviceId}: ${err}`);
+            }
+        }
+    }
+    sampleEnergyHistory() {
+        const historyDir = join(OPENBRIDGE_HOME, 'energy-history');
+        mkdirSync(historyDir, { recursive: true });
+        for (const instance of this.registry.getAll()) {
+            if (!instance.devices)
+                continue;
+            for (const device of Object.values(instance.devices)) {
+                if (device.widgetType !== 'energy_meter')
+                    continue;
+                const energy = instance.telemetry?.[device.id]?.totalForwardEnergy;
+                if (energy === undefined || energy === null)
+                    continue;
+                const filePath = join(historyDir, `${device.id}.json`);
+                let samples = [];
+                try {
+                    samples = JSON.parse(readFileSync(filePath, 'utf8'));
+                }
+                catch {
+                    /* start fresh */
+                }
+                const now = new Date().toISOString();
+                samples.push({ t: now, e: Number(energy) });
+                // Keep only 2 years of 5-minute samples ≈ 210k entries max
+                const cutoff = new Date(Date.now() - 2 * 365 * 24 * 60 * 60 * 1000).toISOString();
+                samples = samples.filter((s) => s.t >= cutoff);
+                writeFileSync(filePath, JSON.stringify(samples));
+            }
+        }
+    }
+}
+function generateUsername(name) {
+    let hash = 0;
+    for (let i = 0; i < name.length; i++) {
+        hash = (hash << 5) - hash + name.charCodeAt(i);
+        hash |= 0;
+    }
+    const h = Math.abs(hash).toString(16).padStart(10, '0');
+    return `${h[0]}${h[1]}:${h[2]}${h[3]}:${h[4]}${h[5]}:${h[6]}${h[7]}:${h[8]}${h[9]}:AB`;
+}
+function printPairingInfo(setupURI, pincode) {
+    try {
+        const qrcode = req('qrcode-terminal');
+        qrcode.generate(setupURI, { small: true }, (qr) => {
+            const border = '─'.repeat(40);
+            console.log(`\n\x1b[35m┌${border}┐\x1b[0m`);
+            console.log(`\x1b[35m│\x1b[0m  \x1b[1mScan to pair with HomeKit\x1b[0m` + ' '.repeat(13) + `\x1b[35m│\x1b[0m`);
+            console.log(`\x1b[35m│\x1b[0m` + ' '.repeat(40) + `\x1b[35m│\x1b[0m`);
+            for (const line of qr.split('\n')) {
+                const pad = ' '.repeat(Math.max(0, 38 - line.length));
+                console.log(`\x1b[35m│\x1b[0m  ${line}${pad}\x1b[35m│\x1b[0m`);
+            }
+            console.log(`\x1b[35m│\x1b[0m` + ' '.repeat(40) + `\x1b[35m│\x1b[0m`);
+            const pinPrefix = '  PIN: ';
+            const pinPad = ' '.repeat(Math.max(0, 40 - pinPrefix.length - pincode.length));
+            console.log(`\x1b[35m│\x1b[0m${pinPrefix}\x1b[1;33m${pincode}\x1b[0m${pinPad}\x1b[35m│\x1b[0m`);
+            console.log(`\x1b[35m└${border}┘\x1b[0m\n`);
+        });
+    }
+    catch {
+        // qrcode-terminal not available: fall back to text
+        console.log(`\n  HomeKit PIN: \x1b[1;33m${pincode}\x1b[0m`);
+        console.log(`  Setup URI:   ${setupURI}\n`);
+    }
+}
+//# sourceMappingURL=daemon.js.map