homebridge-windy-camera 1.0.0

package/README.md

@@ -0,0 +1,68 @@
+# homebridge-windy-camera
+
+Captures a live Windy.com radar map screenshot on a timer and keeps it
+registered as a camera accessory inside
+[homebridge-camera-ui](https://www.npmjs.com/package/homebridge-camera-ui).
+
+This plugin does not implement HomeKit camera streaming itself — it
+relies on `homebridge-camera-ui` (which must already be installed and
+configured) to handle the actual HomeKit video pipeline. Instead, it:
+
+1. Periodically launches headless Chromium (via `playwright-core`) to
+   screenshot the Windy.com embed map for a configured location, and
+   saves it to disk.
+2. On every Homebridge start, makes sure a matching camera entry exists
+   in `homebridge-camera-ui`'s configuration and database — recreating
+   it automatically if it's missing (for example after a partial
+   backup restore).
+
+## Requirements
+
+- `homebridge-camera-ui` already installed and configured.
+- A system-installed Chromium browser (e.g. `/usr/bin/chromium` on
+  Raspberry Pi OS / Debian).
+
+## Installation
+
+```
+sudo npm install -g homebridge-windy-camera
+```
+
+The plugin's `postinstall` script will automatically create a
+Homebridge `prestart` hook (under `/etc/hb-service/homebridge/prestart.d/`)
+that keeps the camera-ui configuration in sync **before** Homebridge
+starts. This is necessary because `homebridge-camera-ui` overwrites its
+own configuration from an internal database on every startup, before
+any regular plugin gets a chance to run.
+
+## Configuration
+
+Add a platform block to your Homebridge `config.json`:
+
+```json
+{
+  "platform": "WindyCamera",
+  "name": "מכ״ם גשם",
+  "lat": 32.3167,
+  "lon": 34.9351,
+  "width": 1300,
+  "height": 900,
+  "captureIntervalMs": 120000
+}
+```
+
+| Option              | Default              | Description                                             |
+|---------------------|-----------------------|----------------------------------------------------------|
+| `name`              | `מכ״ם גשם`            | Camera name shown in HomeKit / used to match the entry.  |
+| `lat` / `lon`        | Tel Aviv area          | Map center coordinates.                                  |
+| `width` / `height`   | 1300 / 900             | Screenshot resolution.                                   |
+| `captureIntervalMs`  | 120000 (2 minutes)     | How often to refresh the radar image.                    |
+| `chromiumPath`       | `/usr/bin/chromium`    | Path to the system Chromium binary.                      |
+
+## How it works
+
+The plugin does not register any HomeKit accessories of its own — its
+only job is to (a) keep a radar screenshot fresh on disk and (b) make
+sure `homebridge-camera-ui` has a `videoConfig` entry pointing at that
+image. The actual HomeKit camera protocol is entirely handled by
+`homebridge-camera-ui`.

package/index.js

@@ -0,0 +1,410 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PLATFORM_NAME = 'WindyCamera';
+const CAMERA_UI_PLATFORM_TYPE = 'CameraUI';
+
+const DEFAULT_NAME = 'מכ״ם גשם';
+const DEFAULT_LAT = 32.3167;
+const DEFAULT_LON = 34.9351;
+const DEFAULT_WIDTH = 1300;
+const DEFAULT_HEIGHT = 900;
+const DEFAULT_CAPTURE_INTERVAL_MS = 120000;
+const DEFAULT_CHROMIUM_PATH = '/usr/bin/chromium';
+
+module.exports = (api) => {
+    api.registerPlatform(PLATFORM_NAME, WindyCameraPlatform);
+};
+
+class WindyCameraPlatform {
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config || {};
+        this.api = api;
+
+        this.name = this.config.name || DEFAULT_NAME;
+        this.lat = this.numberOr(this.config.lat, DEFAULT_LAT);
+        this.lon = this.numberOr(this.config.lon, DEFAULT_LON);
+        this.width = this.numberOr(this.config.width, DEFAULT_WIDTH);
+        this.height = this.numberOr(this.config.height, DEFAULT_HEIGHT);
+        this.captureIntervalMs = this.numberOr(
+            this.config.captureIntervalMs,
+            DEFAULT_CAPTURE_INTERVAL_MS
+        );
+        this.chromiumPath = this.config.chromiumPath || DEFAULT_CHROMIUM_PATH;
+
+        const storageDir = path.join(
+            this.api.user.storagePath(),
+            'windy-camera'
+        );
+
+        this.imageDir = storageDir;
+        this.imagePath = this.config.imagePath ||
+            path.join(storageDir, 'rain.jpg');
+
+        this.captureUrl = this.buildCaptureUrl();
+
+        this.cameraUIDatabasePath = this.config.cameraUIDatabasePath ||
+            path.join(
+                this.api.user.storagePath(),
+                'camera.ui',
+                'database',
+                'database.json'
+            );
+
+        this.captureTimer = null;
+        this.capturing = false;
+
+        this.log.info(
+            `Windy Camera platform loaded. Image path: ${this.imagePath}`
+        );
+
+        this.api.on('didFinishLaunching', () => {
+            this.onLaunched();
+        });
+
+        this.api.on('shutdown', () => {
+            this.stopCaptureLoop();
+        });
+    }
+
+    configureAccessory() {}
+
+    numberOr(value, fallback) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : fallback;
+    }
+
+    buildCaptureUrl() {
+        const params = new URLSearchParams({
+            lat: String(this.lat),
+            lon: String(this.lon),
+            detailLat: String(this.lat),
+            detailLon: String(this.lon),
+            width: String(this.width),
+            height: String(this.height),
+            zoom: '9',
+            level: 'surface',
+            overlay: 'radar',
+            product: 'radar',
+            menu: '',
+            message: 'true',
+            marker: '',
+            calendar: 'now',
+            pressure: 'false',
+            type: 'map',
+            location: 'coordinates',
+            detail: '',
+            metricWind: 'default',
+            metricTemp: 'default',
+            radarRange: '-1'
+        });
+
+        return `https://embed.windy.com/embed2.html?${params.toString()}`;
+    }
+
+    async onLaunched() {
+        try {
+            fs.mkdirSync(this.imageDir, { recursive: true });
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: could not create image directory: ${error.message}`
+            );
+        }
+
+        this.ensureCameraUIConfig();
+        this.ensureCameraUIDatabase();
+
+        await this.capture();
+
+        this.captureTimer = setInterval(() => {
+            this.capture();
+        }, this.captureIntervalMs);
+    }
+
+    stopCaptureLoop() {
+        if (this.captureTimer) {
+            clearInterval(this.captureTimer);
+            this.captureTimer = null;
+        }
+    }
+
+    async capture() {
+        if (this.capturing) {
+            return;
+        }
+
+        this.capturing = true;
+
+        let chromium;
+
+        try {
+            ({ chromium } = require('playwright-core'));
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: playwright-core is not installed: ${error.message}`
+            );
+            this.capturing = false;
+            return;
+        }
+
+        let browser;
+
+        try {
+            browser = await chromium.launch({
+                executablePath: this.chromiumPath,
+                headless: true,
+                args: [
+                    '--no-sandbox',
+                    '--disable-dev-shm-usage',
+                    '--hide-scrollbars',
+                    '--disable-gpu'
+                ]
+            });
+
+            const context = await browser.newContext({
+                viewport: {
+                    width: this.width,
+                    height: this.height
+                },
+                deviceScaleFactor: 1,
+                geolocation: {
+                    latitude: this.lat,
+                    longitude: this.lon
+                },
+                permissions: ['geolocation']
+            });
+
+            const page = await context.newPage();
+
+            await page.goto(this.captureUrl, {
+                waitUntil: 'domcontentloaded',
+                timeout: 60000
+            });
+
+            await page.waitForTimeout(15000);
+
+            const tempPath = `${this.imagePath}.tmp`;
+
+            await page.screenshot({
+                path: tempPath,
+                type: 'jpeg',
+                quality: 95
+            });
+
+            fs.renameSync(tempPath, this.imagePath);
+
+            this.log.debug('Windy Camera: radar frame updated');
+
+            await browser.close();
+            browser = null;
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: capture failed: ${error.message}`
+            );
+
+            if (browser) {
+                try {
+                    await browser.close();
+                } catch {
+                    // ignore
+                }
+            }
+        } finally {
+            this.capturing = false;
+        }
+    }
+
+    ensureCameraUIConfig() {
+        const configPath = this.api.user.configPath();
+
+        let raw;
+
+        try {
+            raw = fs.readFileSync(configPath, 'utf8');
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: could not read config.json: ${error.message}`
+            );
+            return;
+        }
+
+        let root;
+
+        try {
+            root = JSON.parse(raw);
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: config.json is not valid JSON, skipping injection: ${error.message}`
+            );
+            return;
+        }
+
+        const platforms = Array.isArray(root.platforms) ?
+            root.platforms :
+            [];
+
+        const cameraUIPlatform = platforms.find(
+            (p) => p && p.platform === CAMERA_UI_PLATFORM_TYPE
+        );
+
+        if (!cameraUIPlatform) {
+            this.log.warn(
+                'Windy Camera: no CameraUI platform found in config.json; ' +
+                'nothing to inject into.'
+            );
+            return;
+        }
+
+        if (!Array.isArray(cameraUIPlatform.cameras)) {
+            cameraUIPlatform.cameras = [];
+        }
+
+        const existing = cameraUIPlatform.cameras.find(
+            (c) => c && c.name === this.name
+        );
+
+        if (existing) {
+            this.log.info(
+                `Windy Camera: camera entry "${this.name}" already present ` +
+                'in camera-ui config.'
+            );
+            return;
+        }
+
+        const cameraEntry = this.buildCameraUIEntry();
+
+        cameraUIPlatform.cameras.push(cameraEntry);
+
+        try {
+            fs.writeFileSync(
+                configPath,
+                JSON.stringify(root, null, 4),
+                'utf8'
+            );
+
+            this.log.warn(
+                `Windy Camera: camera entry "${this.name}" was missing and ` +
+                'has been re-created in config.json. Restart Homebridge ' +
+                'for camera-ui to pick it up.'
+            );
+        } catch (error) {
+            this.log.error(
+                `Windy Camera: failed to write config.json: ${error.message}`
+            );
+        }
+    }
+
+    ensureCameraUIDatabase() {
+        let raw;
+
+        try {
+            raw = fs.readFileSync(this.cameraUIDatabasePath, 'utf8');
+        } catch (error) {
+            this.log.warn(
+                'Windy Camera: could not read camera.ui database.json ' +
+                `(${error.message}); skipping database-level injection.`
+            );
+            return;
+        }
+
+        let db;
+
+        try {
+            db = JSON.parse(raw);
+        } catch (error) {
+            this.log.error(
+                'Windy Camera: camera.ui database.json is not valid JSON, ' +
+                `skipping injection: ${error.message}`
+            );
+            return;
+        }
+
+        if (!Array.isArray(db.cameras)) {
+            db.cameras = [];
+        }
+
+        const existing = db.cameras.find(
+            (c) => c && c.name === this.name
+        );
+
+        if (existing) {
+            this.log.info(
+                `Windy Camera: camera entry "${this.name}" already present ` +
+                'in camera.ui database.'
+            );
+            return;
+        }
+
+        db.cameras.push(this.buildCameraUIEntry());
+
+        try {
+            fs.writeFileSync(
+                this.cameraUIDatabasePath,
+                JSON.stringify(db, null, 4),
+                'utf8'
+            );
+
+            this.log.warn(
+                `Windy Camera: camera entry "${this.name}" was missing and ` +
+                'has been re-created in camera.ui database.json. Restart ' +
+                'Homebridge for camera-ui to pick it up.'
+            );
+        } catch (error) {
+            this.log.error(
+                'Windy Camera: failed to write camera.ui database.json: ' +
+                error.message
+            );
+        }
+    }
+
+    buildCameraUIEntry() {
+        const source = `-loop 1 -i ${this.imagePath}`;
+        const stillImageSource = `-i ${this.imagePath}`;
+
+        return {
+            disable: false,
+            name: this.name,
+            excludeSwitch: false,
+            privacySwitch: false,
+            motion: false,
+            doorbell: false,
+            switches: false,
+            useInterfaceTimer: false,
+            motionTimeout: 15,
+            unbridge: true,
+            hsv: false,
+            prebuffering: false,
+            hksvConfig: {
+                audio: false
+            },
+            videoConfig: {
+                source,
+                subSource: source,
+                stillImageSource,
+                readRate: false,
+                maxStreams: 2,
+                maxWidth: this.width,
+                maxHeight: this.height,
+                maxFPS: 1,
+                maxBitrate: 6000,
+                forceMax: true,
+                vcodec: 'libx264',
+                acodec: 'libfdk_aac',
+                audio: false,
+                debug: false,
+                debugReturn: false
+            },
+            smtp: {
+                email: this.name
+            },
+            videoanalysis: {
+                active: false
+            },
+            prebufferLength: 4,
+            mqtt: {}
+        };
+    }
+}

package/inject-camera.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+import json
+import sys
+
+CONFIG_PATH = '/var/lib/homebridge/config.json'
+DB_PATH = '/var/lib/homebridge/camera.ui/database/database.json'
+STORAGE_PATH = '/var/lib/homebridge'
+DEFAULT_IMAGE_PATH = STORAGE_PATH + '/windy-camera/rain.jpg'
+
+
+def build_entry(name, image_path, width, height):
+    source = f'-loop 1 -i {image_path}'
+    still = f'-i {image_path}'
+    return {
+        "disable": False,
+        "name": name,
+        "excludeSwitch": False,
+        "privacySwitch": False,
+        "motion": False,
+        "doorbell": False,
+        "switches": False,
+        "useInterfaceTimer": False,
+        "motionTimeout": 15,
+        "unbridge": True,
+        "hsv": False,
+        "prebuffering": False,
+        "hksvConfig": {"audio": False},
+        "videoConfig": {
+            "source": source,
+            "subSource": source,
+            "stillImageSource": still,
+            "readRate": False,
+            "maxStreams": 2,
+            "maxWidth": width,
+            "maxHeight": height,
+            "maxFPS": 1,
+            "maxBitrate": 6000,
+            "forceMax": True,
+            "vcodec": "libx264",
+            "acodec": "libfdk_aac",
+            "audio": False,
+            "debug": False,
+            "debugReturn": False
+        },
+        "smtp": {"email": name},
+        "videoanalysis": {"active": False},
+        "prebufferLength": 4,
+        "mqtt": {}
+    }
+
+
+def main():
+    try:
+        with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+    except Exception as e:
+        print(f"windy-camera-inject: cannot read config.json: {e}")
+        return
+
+    platforms = config.get('platforms', [])
+
+    windy_platform = next(
+        (p for p in platforms if p.get('platform') == 'WindyCamera'),
+        None
+    )
+
+    if not windy_platform:
+        print("windy-camera-inject: no WindyCamera platform configured, skipping.")
+        return
+
+    name = windy_platform.get('name', 'מכ״ם גשם')
+    image_path = windy_platform.get('imagePath', DEFAULT_IMAGE_PATH)
+    width = windy_platform.get('width', 1300)
+    height = windy_platform.get('height', 900)
+
+    entry = build_entry(name, image_path, width, height)
+
+    camera_ui_platform = next(
+        (p for p in platforms if p.get('platform') == 'CameraUI'),
+        None
+    )
+
+    changed_config = False
+
+    if camera_ui_platform is not None:
+        cams = camera_ui_platform.setdefault('cameras', [])
+        if not any(c.get('name') == name for c in cams):
+            cams.append(entry)
+            changed_config = True
+
+    if changed_config:
+        with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=4, ensure_ascii=False)
+        print(f'windy-camera-inject: added "{name}" to config.json')
+    else:
+        print(f'windy-camera-inject: "{name}" already present in config.json')
+
+    try:
+        with open(DB_PATH, 'r', encoding='utf-8') as f:
+            db = json.load(f)
+    except Exception as e:
+        print(f"windy-camera-inject: cannot read camera.ui database.json: {e}")
+        return
+
+    db_cams = db.setdefault('cameras', [])
+    changed_db = False
+
+    if not any(c.get('name') == name for c in db_cams):
+        db_cams.append(entry)
+        changed_db = True
+
+    if changed_db:
+        with open(DB_PATH, 'w', encoding='utf-8') as f:
+            json.dump(db, f, indent=4, ensure_ascii=False)
+        print(f'windy-camera-inject: added "{name}" to camera.ui database.json')
+    else:
+        print(f'windy-camera-inject: "{name}" already present in camera.ui database.json')
+
+
+if __name__ == '__main__':
+    main()

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "homebridge-windy-camera",
+  "version": "1.0.0",
+  "description": "Captures a live Windy.com radar map screenshot and keeps it registered as a camera inside homebridge-camera-ui",
+  "main": "index.js",
+  "keywords": ["homebridge-plugin"],
+  "files": [
+    "index.js",
+    "inject-camera.py",
+    "scripts/postinstall.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js || true"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "homebridge": "^1.6.0 || ^2.0.0"
+  },
+  "dependencies": {
+    "playwright-core": "^1.40.0"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PRESTART_DIR = '/etc/hb-service/homebridge/prestart.d';
+const PRESTART_FILE = path.join(PRESTART_DIR, '20-windy-camera-inject');
+const INJECT_SCRIPT = path.join(__dirname, '..', 'inject-camera.py');
+
+function log(message) {
+    console.log(`[homebridge-windy-camera] postinstall: ${message}`);
+}
+
+function main() {
+    if (!fs.existsSync(PRESTART_DIR)) {
+        log(
+            `${PRESTART_DIR} does not exist (not running under hb-service?). ` +
+            'Skipping prestart hook installation — you will need to set ' +
+            'this up manually. See the plugin README.'
+        );
+        return;
+    }
+
+    if (!fs.existsSync(INJECT_SCRIPT)) {
+        log(
+            `expected helper script not found at ${INJECT_SCRIPT}; ` +
+            'skipping prestart hook installation.'
+        );
+        return;
+    }
+
+    const scriptContents =
+        '#!/bin/sh\n' +
+        `python3 ${INJECT_SCRIPT}\n`;
+
+    try {
+        fs.writeFileSync(PRESTART_FILE, scriptContents, {
+            mode: 0o755
+        });
+
+        fs.chmodSync(PRESTART_FILE, 0o755);
+
+        log(`prestart hook installed at ${PRESTART_FILE}`);
+    } catch (error) {
+        log(
+            `could not write prestart hook (${error.message}). ` +
+            `You may need to create it manually: sudo tee ${PRESTART_FILE}`
+        );
+        return;
+    }
+
+    try {
+        const { execFileSync } = require('child_process');
+        execFileSync('python3', [INJECT_SCRIPT], { stdio: 'inherit' });
+    } catch (error) {
+        log(
+            `initial camera injection run failed (${error.message}). ` +
+            'It will still run automatically on the next Homebridge start.'
+        );
+    }
+}
+
+try {
+    main();
+} catch (error) {
+    log(`unexpected error, continuing anyway: ${error.message}`);
+}