iobroker.motioneye 0.0.1

package/lib/adapter-config.d.ts

@@ -0,0 +1,19 @@
+// This file extends the AdapterConfig type from "@iobroker/types"
+// using the actual properties present in io-package.json
+// in order to provide typings for adapter.config properties
+
+import { native } from '../io-package.json';
+
+type _AdapterConfig = typeof native;
+
+// Augment the globally declared type ioBroker.AdapterConfig
+declare global {
+	namespace ioBroker {
+		interface AdapterConfig extends _AdapterConfig {
+			// Do not enter anything here!
+		}
+	}
+}
+
+// this is required so the above AdapterConfig is found by TypeScript / type checking
+export {};

package/lib/cameraRegistry.js

@@ -0,0 +1,160 @@
+'use strict';
+
+/**
+ * Sanitize a user-chosen camera name for ioBroker channel IDs.
+ * @param {string} name
+ * @returns {string}
+ */
+function safeChannelName(name) {
+	return String(name)
+		.trim()
+		.replace(/\s+/g, '_')
+		.replace(/[^a-zA-Z0-9_äöüÄÖÜß-]/g, '_');
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function slugifyId(value) {
+	return safeChannelName(value)
+		.toLowerCase()
+		.replace(/[^a-z0-9_-]/g, '_')
+		.replace(/_+/g, '_')
+		.replace(/^_|_$/g, '');
+}
+
+/**
+ * @typedef {object} NativeCameraConfig
+ * @property {string} [id]
+ * @property {string} name
+ * @property {number} motionEyeId
+ * @property {boolean} [enabled]
+ * @property {string} [defaultMode]
+ */
+
+/**
+ * @typedef {object} ResolvedCamera
+ * @property {string} id Internal webhook key
+ * @property {string} name Display name
+ * @property {string} channel Channel ID under adapter namespace
+ * @property {number} motionEyeId
+ * @property {boolean} enabled
+ * @property {string} defaultMode
+ */
+
+/**
+ * @param {NativeCameraConfig[]} cameras
+ * @param {string} fallbackDefaultMode
+ * @returns {ResolvedCamera[]}
+ */
+function resolveCameras(cameras, fallbackDefaultMode = 'off') {
+	if (!Array.isArray(cameras)) {
+		return [];
+	}
+
+	/** @type {ResolvedCamera[]} */
+	const resolved = [];
+	const usedIds = new Set();
+	const usedChannels = new Set();
+
+	for (const entry of cameras) {
+		if (!entry || !entry.name || entry.motionEyeId == null) {
+			continue;
+		}
+
+		const name = String(entry.name).trim();
+		const channel = safeChannelName(name);
+		if (!channel) {
+			continue;
+		}
+
+		let id = entry.id ? slugifyId(entry.id) : slugifyId(name);
+		if (!id) {
+			id = `cam_${entry.motionEyeId}`;
+		}
+
+		let uniqueId = id;
+		let suffix = 2;
+		while (usedIds.has(uniqueId)) {
+			uniqueId = `${id}_${suffix}`;
+			suffix += 1;
+		}
+
+		let uniqueChannel = channel;
+		suffix = 2;
+		while (usedChannels.has(uniqueChannel)) {
+			uniqueChannel = `${channel}_${suffix}`;
+			suffix += 1;
+		}
+
+		usedIds.add(uniqueId);
+		usedChannels.add(uniqueChannel);
+
+		resolved.push({
+			id: uniqueId,
+			name,
+			channel: uniqueChannel,
+			motionEyeId: Number(entry.motionEyeId),
+			enabled: entry.enabled !== false,
+			defaultMode: entry.defaultMode || fallbackDefaultMode,
+		});
+	}
+
+	return resolved;
+}
+
+/**
+ * @param {string} namespace Adapter namespace (e.g. motioneye.0)
+ * @param {string} webhookHost ioBroker host reachable from MotionEye
+ * @param {number} webhookPort
+ * @param {string} cameraId Internal camera key
+ * @returns {string}
+ */
+function buildWebhookUrl(namespace, webhookHost, webhookPort, cameraId) {
+	const host = String(webhookHost).trim();
+	const port = Number(webhookPort);
+	return `http://${host}:${port}/${namespace}/webhook/${encodeURIComponent(cameraId)}?value=true`;
+}
+
+/**
+ * @param {string} path Request path including query string
+ * @param {string} namespace Adapter namespace (e.g. motioneye.0)
+ * @returns {{ cameraId: string, value: boolean } | null}
+ */
+function parseWebhookRequest(path, namespace) {
+	const pathOnly = path.split('?')[0];
+	const prefix = `/${namespace}/webhook/`;
+	if (!pathOnly.startsWith(prefix)) {
+		return null;
+	}
+
+	const cameraId = decodeURIComponent(pathOnly.slice(prefix.length).replace(/\/+$/, ''));
+	if (!cameraId) {
+		return null;
+	}
+
+	const query = path.includes('?') ? path.slice(path.indexOf('?') + 1) : '';
+	let value = true;
+	for (const part of query.split('&')) {
+		if (!part) {
+			continue;
+		}
+		const eq = part.indexOf('=');
+		const key = eq >= 0 ? decodeURIComponent(part.slice(0, eq)) : decodeURIComponent(part);
+		if (key === 'value') {
+			const raw = eq >= 0 ? decodeURIComponent(part.slice(eq + 1)) : '';
+			value = !['0', 'false', 'off', 'no'].includes(String(raw).trim().toLowerCase());
+		}
+	}
+
+	return { cameraId, value };
+}
+
+module.exports = {
+	safeChannelName,
+	slugifyId,
+	resolveCameras,
+	buildWebhookUrl,
+	parseWebhookRequest,
+};

package/lib/cameraRegistry.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { expect } = require('chai');
+const {
+	safeChannelName,
+	slugifyId,
+	resolveCameras,
+	buildWebhookUrl,
+	parseWebhookRequest,
+} = require('./cameraRegistry');
+
+describe('cameraRegistry', () => {
+	it('safeChannelName should replace spaces and strip unsafe characters', () => {
+		expect(safeChannelName('Innenhof II')).to.equal('Innenhof_II');
+		expect(safeChannelName('  Auffahrt  ')).to.equal('Auffahrt');
+	});
+
+	it('slugifyId should produce lowercase stable ids', () => {
+		expect(slugifyId('Innenhof II')).to.equal('innenhof_ii');
+	});
+
+	it('resolveCameras should skip invalid entries and deduplicate ids', () => {
+		const cameras = resolveCameras(
+			[
+				{ name: 'Auffahrt', motionEyeId: 1 },
+				{ name: 'Auffahrt', motionEyeId: 2, id: 'auffahrt' },
+				{ name: '', motionEyeId: 3 },
+				{ name: 'Carport', motionEyeId: 2, enabled: false },
+			],
+			'still',
+		);
+
+		expect(cameras).to.have.length(3);
+		expect(cameras[0].channel).to.equal('Auffahrt');
+		expect(cameras[0].defaultMode).to.equal('still');
+		expect(cameras[1].id).to.equal('auffahrt_2');
+		expect(cameras[2].enabled).to.equal(false);
+	});
+
+	it('buildWebhookUrl should include namespace and camera id', () => {
+		const url = buildWebhookUrl('motioneye.0', '192.168.1.10', 8090, 'auffahrt');
+		expect(url).to.equal('http://192.168.1.10:8090/motioneye.0/webhook/auffahrt?value=true');
+	});
+
+	it('parseWebhookRequest should parse value query parameter', () => {
+		expect(parseWebhookRequest('/motioneye.0/webhook/auffahrt?value=true', 'motioneye.0')).to.deep.equal({
+			cameraId: 'auffahrt',
+			value: true,
+		});
+		expect(parseWebhookRequest('/motioneye.0/webhook/carport?value=false', 'motioneye.0')).to.deep.equal({
+			cameraId: 'carport',
+			value: false,
+		});
+		expect(parseWebhookRequest('/other/path', 'motioneye.0')).to.equal(null);
+	});
+});

package/lib/modeProfiles.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/** @type {Record<string, string>} */
+const MODE_ALIASES = {
+	off: 'off',
+	aus: 'off',
+	0: 'off',
+	false: 'off',
+	still: 'still',
+	ruhig: 'still',
+	trigger: 'still',
+	sharp: 'sharp',
+	scharf: 'sharp',
+	armed: 'sharp',
+	1: 'sharp',
+	true: 'sharp',
+};
+
+/** @type {Record<string, Record<string, unknown>>} */
+const MODE_PROFILES = {
+	off: {
+		motion_detection: false,
+		movies: false,
+		web_hook_notifications_enabled: false,
+	},
+	still: {
+		motion_detection: true,
+		movies: false,
+		web_hook_notifications_enabled: true,
+		web_hook_notifications_http_method: 'GET',
+	},
+	sharp: {
+		motion_detection: true,
+		movies: true,
+		recording_mode: 'motion-triggered',
+		movie_format: 'mp4',
+		web_hook_notifications_enabled: true,
+		web_hook_notifications_http_method: 'GET',
+	},
+};
+
+/** @type {Record<string, string>} */
+const MODE_LABELS = {
+	off: 'Off',
+	still: 'Still',
+	sharp: 'Sharp',
+};
+
+/** Snapshot media defaults applied on adapter start when enabled. */
+const MEDIA_SETTINGS = {
+	still_images: true,
+	capture_mode: 'manual',
+	manual_snapshots: true,
+};
+
+/**
+ * @param {unknown} value
+ * @returns {'off'|'still'|'sharp'|null}
+ */
+function normalizeMode(value) {
+	const key = String(value == null ? '' : value)
+		.trim()
+		.toLowerCase();
+	return /** @type {'off'|'still'|'sharp'|null} */ (MODE_ALIASES[key] || null);
+}
+
+/**
+ * @param {Record<string, unknown>} uiConfig MotionEye camera config
+ * @returns {'off'|'still'|'sharp'}
+ */
+function inferModeFromConfig(uiConfig) {
+	if (!uiConfig.motion_detection) {
+		return 'off';
+	}
+	if (uiConfig.movies) {
+		return 'sharp';
+	}
+	return 'still';
+}
+
+/**
+ * @param {'off'|'still'|'sharp'} mode
+ * @param {string} [webhookUrl]
+ * @returns {Record<string, unknown>}
+ */
+function buildModePatch(mode, webhookUrl) {
+	const patch = { ...MODE_PROFILES[mode] };
+	if ((mode === 'still' || mode === 'sharp') && webhookUrl) {
+		patch.web_hook_notifications_url = webhookUrl;
+	}
+	return patch;
+}
+
+module.exports = {
+	MODE_ALIASES,
+	MODE_PROFILES,
+	MODE_LABELS,
+	MEDIA_SETTINGS,
+	normalizeMode,
+	inferModeFromConfig,
+	buildModePatch,
+};

package/lib/modeProfiles.test.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { expect } = require('chai');
+const { normalizeMode, inferModeFromConfig, buildModePatch } = require('./modeProfiles');
+
+describe('modeProfiles', () => {
+	it('normalizeMode should accept aliases', () => {
+		expect(normalizeMode('scharf')).to.equal('sharp');
+		expect(normalizeMode('aus')).to.equal('off');
+		expect(normalizeMode('trigger')).to.equal('still');
+		expect(normalizeMode('unknown')).to.equal(null);
+	});
+
+	it('inferModeFromConfig should derive mode from MotionEye flags', () => {
+		expect(inferModeFromConfig({ motion_detection: false, movies: false })).to.equal('off');
+		expect(inferModeFromConfig({ motion_detection: true, movies: false })).to.equal('still');
+		expect(inferModeFromConfig({ motion_detection: true, movies: true })).to.equal('sharp');
+	});
+
+	it('buildModePatch should include webhook URL for still and sharp', () => {
+		const still = buildModePatch('still', 'http://iobroker:8090/motioneye.0/webhook/cam?value=true');
+		expect(still.motion_detection).to.equal(true);
+		expect(still.movies).to.equal(false);
+		expect(still.web_hook_notifications_url).to.include('webhook/cam');
+
+		const sharp = buildModePatch('sharp', 'http://iobroker/webhook');
+		expect(sharp.movie_format).to.equal('mp4');
+		expect(sharp.recording_mode).to.equal('motion-triggered');
+	});
+
+	it('buildModePatch off should disable webhook', () => {
+		const off = buildModePatch('off');
+		expect(off.web_hook_notifications_enabled).to.equal(false);
+		expect(off).to.not.have.property('web_hook_notifications_url');
+	});
+});

package/lib/motionApi.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const http = require('node:http');
+
+/**
+ * @typedef {object} MotionApiOptions
+ * @property {string} host MotionEye / Motion host
+ * @property {number} [motionPort=7999]
+ * @property {number} [requestTimeoutMs=45000]
+ */
+
+/**
+ * Motion HTTP API client (snapshots on motionPort).
+ * @param {MotionApiOptions} options
+ */
+function createMotionApi(options) {
+	const host = options.host;
+	const motionPort = options.motionPort ?? 7999;
+	const requestTimeoutMs = options.requestTimeoutMs ?? 45000;
+
+	/**
+	 * @param {string} path
+	 * @param {string} [method]
+	 * @returns {Promise<{ status: number, body: string }>}
+	 */
+	function request(path, method = 'GET') {
+		return new Promise((resolve, reject) => {
+			const req = http.request(
+				{
+					hostname: host,
+					port: motionPort,
+					path,
+					method,
+					timeout: requestTimeoutMs,
+				},
+				res => {
+					let body = '';
+					res.setEncoding('utf8');
+					res.on('data', chunk => {
+						body += chunk;
+					});
+					res.on('end', () => {
+						if ((res.statusCode || 0) >= 400) {
+							reject(new Error(`Motion HTTP ${res.statusCode}: ${body.trim() || path}`));
+							return;
+						}
+						resolve({ status: res.statusCode || 0, body: body.trim() });
+					});
+				},
+			);
+
+			req.on('timeout', () => {
+				req.destroy();
+				reject(new Error(`Timeout after ${requestTimeoutMs} ms: ${path}`));
+			});
+			req.on('error', reject);
+			req.end();
+		});
+	}
+
+	return {
+		/**
+		 * @param {number} cameraId MotionEye camera ID
+		 */
+		takeSnapshot(cameraId) {
+			return request(`/${cameraId}/action/snapshot`, 'GET');
+		},
+	};
+}
+
+module.exports = {
+	createMotionApi,
+};