@camera.ui/server 0.0.69 → 0.0.71-dev.0

package/dist/server/src/manager/discoveryManager.js

@@ -0,0 +1,800 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { RPCClass, RPCMethod } from '@camera.ui/rpc';
+import { isDiscoveryProvider } from '@camera.ui/sdk/internal';
+import { TTLCache } from '@isaacs/ttlcache';
+import { container } from 'tsyringe';
+import { createCameraSchema } from '../api/schemas/cameras.schema.js';
+import { CamerasService } from '../api/services/cameras.service.js';
+import { PluginsService } from '../api/services/plugins.service.js';
+import { NamespaceManager } from '../rpc/namespaces.js';
+const DISCOVERED_CACHE_TTL_MS = 300_000;
+const MIN_SCAN_INTERVAL_MS = 30_000;
+const AUTO_RESCAN_INTERVAL_MS = 60_000;
+let DiscoveryManager = class DiscoveryManager {
+    api;
+    proxyServer;
+    pluginsService;
+    camerasService;
+    configService;
+    go2rtcApi;
+    logger;
+    discoveredCamerasCache = new TTLCache({
+        ttl: DISCOVERED_CACHE_TTL_MS,
+        max: 500,
+    });
+    sourceCache = new Map();
+    isScanning = false;
+    connectionStates = new Map();
+    subscriberCount = 0;
+    scannedCameraIds = new Set();
+    initialScanLogged = false;
+    lastScanCompletedAt = 0;
+    autoRescanTimer;
+    namespaces = NamespaceManager.discoveryManagerNamespaces();
+    closeProxy;
+    constructor() {
+        this.api = container.resolve('api');
+        this.proxyServer = container.resolve('proxy');
+        this.go2rtcApi = container.resolve('go2rtcApi');
+        this.logger = container.resolve('logger');
+        this.configService = container.resolve('configService');
+        this.pluginsService = new PluginsService();
+        this.camerasService = new CamerasService();
+    }
+    async register() {
+        this.closeProxy = await this.proxyServer.proxy.registerHandler(this.namespaces.discoveryManagerRpc, this);
+    }
+    async destroy() {
+        this.stopAutoRescanTimer();
+        this.discoveredCamerasCache.clear();
+        this.sourceCache.clear();
+        this.connectionStates.clear();
+        this.scannedCameraIds.clear();
+        await this.closeProxy?.();
+    }
+    subscribe() {
+        const isFirstSubscriber = this.subscriberCount === 0;
+        this.subscriberCount++;
+        if (isFirstSubscriber) {
+            this.startAutoRescanTimer();
+        }
+        const cachedDevices = this.mergeResults();
+        const timeSinceLastScan = Date.now() - this.lastScanCompletedAt;
+        const hasCachedDiscoveredDevices = this.sourceCache.size > 0;
+        const cacheIsFresh = hasCachedDiscoveredDevices && timeSinceLastScan < MIN_SCAN_INTERVAL_MS;
+        if (!this.isScanning && !cacheIsFresh) {
+            this.discoverCameras();
+        }
+        return cachedDevices;
+    }
+    isScanningNow() {
+        return this.isScanning;
+    }
+    unsubscribe() {
+        this.subscriberCount = Math.max(0, this.subscriberCount - 1);
+        if (this.subscriberCount === 0) {
+            this.stopAutoRescanTimer();
+        }
+    }
+    getSubscriberCount() {
+        return this.subscriberCount;
+    }
+    startAutoRescanTimer() {
+        this.stopAutoRescanTimer();
+        this.autoRescanTimer = setInterval(() => {
+            if (this.subscriberCount > 0 && !this.isScanning) {
+                this.logger.debug('[Discovery] Auto-rescan triggered');
+                this.discoverCameras();
+            }
+        }, AUTO_RESCAN_INTERVAL_MS);
+    }
+    stopAutoRescanTimer() {
+        if (this.autoRescanTimer) {
+            clearInterval(this.autoRescanTimer);
+            this.autoRescanTimer = undefined;
+        }
+    }
+    async discoverCameras() {
+        if (this.isScanning) {
+            this.logger.debug('[Discovery] Scan already in progress, skipping');
+            return;
+        }
+        this.isScanning = true;
+        this.scannedCameraIds.clear();
+        this.broadcastScanningStatus(true);
+        try {
+            // Send DB cameras first so the user sees existing cameras while scans run.
+            const dbDevices = this.fetchDbCameras();
+            if (dbDevices.length > 0) {
+                this.broadcastDiscovered(dbDevices, 'database');
+            }
+            // Track manual-camera addresses so go2rtc duplicates can be filtered out.
+            const manualCameraAddresses = new Set();
+            for (const device of dbDevices) {
+                if (device.provider === 'camera.ui') {
+                    const address = this.extractAddressFromDbCamera(device);
+                    if (address) {
+                        manualCameraAddresses.add(address);
+                    }
+                }
+            }
+            const discoveryPlugins = this.getDiscoveryPlugins();
+            const sources = ['go2rtc', ...discoveryPlugins.map((p) => `plugin-${p.id}`)];
+            await Promise.all(sources.map(async (sourceId) => {
+                try {
+                    let cameras;
+                    if (sourceId === 'go2rtc') {
+                        cameras = await this.fetchGo2rtcCameras();
+                        cameras = cameras.filter((c) => {
+                            if (c._internalAddress && manualCameraAddresses.has(c._internalAddress)) {
+                                return false;
+                            }
+                            return true;
+                        });
+                    }
+                    else {
+                        const pluginId = sourceId.replace('plugin-', '');
+                        cameras = await this.fetchPluginCameras(pluginId);
+                    }
+                    const uniqueCameras = cameras.filter((c) => {
+                        if (this.scannedCameraIds.has(c.id)) {
+                            return false;
+                        }
+                        this.scannedCameraIds.add(c.id);
+                        return true;
+                    });
+                    if (uniqueCameras.length > 0) {
+                        this.updateSourceCache(sourceId, uniqueCameras);
+                        const devices = uniqueCameras.map((c) => this.toDeviceListItem(c));
+                        this.broadcastDiscovered(devices, sourceId);
+                    }
+                    else {
+                        this.updateSourceCache(sourceId, []);
+                    }
+                }
+                catch (error) {
+                    this.logger.debug(`[Discovery] Scan failed for ${sourceId}:`, error);
+                    // Preserve last-known cameras on error so we don't drop entries from the UI.
+                    this.updateSourceCache(sourceId, this.sourceCache.get(sourceId)?.cameras ?? [], error instanceof Error ? error.message : 'Unknown error');
+                }
+            }));
+            this.cleanupOrphanedCameras(new Set(['database', ...sources]));
+            this.logDiscoverySummary();
+        }
+        finally {
+            this.isScanning = false;
+            this.lastScanCompletedAt = Date.now();
+            this.broadcastScanningStatus(false);
+        }
+    }
+    async forceRescan() {
+        this.sourceCache.clear();
+        this.discoveredCamerasCache.clear();
+        this.initialScanLogged = false;
+        this.lastScanCompletedAt = 0;
+        await this.discoverCameras();
+    }
+    async getCameraSettings(discoveredId) {
+        if (discoveredId.startsWith('go2rtc:')) {
+            return this.getGo2rtcCameraSettings(discoveredId);
+        }
+        const { plugin, camera } = this.findDiscoveredCamera(discoveredId);
+        if (plugin && camera) {
+            if (!plugin.worker?.isRunning()) {
+                throw new Error(`Plugin "${plugin.pluginName}" is not running`);
+            }
+            const result = await plugin.worker.pluginProxy.onGetCameraSettings?.(camera);
+            return result ?? [];
+        }
+        throw new Error(`Camera "${discoveredId}" not found`);
+    }
+    async adoptCamera(discoveredId, cameraSettings) {
+        this.setConnectionState(discoveredId, 'connecting');
+        this.broadcastConnectionStatus(discoveredId);
+        try {
+            let result;
+            if (discoveredId.startsWith('go2rtc:')) {
+                result = await this.adoptGo2rtcCamera(discoveredId, cameraSettings);
+            }
+            else {
+                result = await this.adoptPluginCamera(discoveredId, cameraSettings);
+            }
+            this.setConnectionState(discoveredId, 'connected');
+            this.broadcastConnectionStatus(discoveredId);
+            this.publishDiscoveryEvent('cameras:camera-connected', {
+                discoveredId,
+                cameraId: result.cameraId,
+                cameraName: result.cameraName,
+            });
+            // The discovery cache now points at a real camera, drop the stale entry.
+            this.removeFromDiscoveredCache(discoveredId);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.setConnectionState(discoveredId, 'error', errorMessage);
+            this.broadcastConnectionStatus(discoveredId);
+            throw error;
+        }
+    }
+    async getConnectionSchema(discoveredId) {
+        return this.getCameraSettings(discoveredId);
+    }
+    async connect(discoveredId, credentials) {
+        return this.adoptCamera(discoveredId, credentials);
+    }
+    // Plugin entry point for asynchronously discovered cameras (e.g., after cloud login).
+    async pushDiscoveredCameras(pluginId, cameras) {
+        const plugin = this.pluginsService.getPluginById(pluginId);
+        if (!plugin) {
+            throw new Error(`Plugin "${pluginId}" not found`);
+        }
+        if (!isDiscoveryProvider(plugin.contract)) {
+            throw new Error(`Plugin "${plugin.pluginName}" is not a discovery provider`);
+        }
+        this.logger.log(`[Discovery] Received ${cameras.length} camera(s) from ${plugin.pluginName}`);
+        const sourceId = `plugin-${pluginId}`;
+        const internalCameras = cameras.map((c) => ({
+            ...c,
+            provider: pluginId,
+        }));
+        this.updateSourceCache(sourceId, internalCameras);
+        if (this.subscriberCount > 0) {
+            const devices = internalCameras.map((c) => this.toDeviceListItem(c));
+            this.broadcastDiscovered(devices, sourceId);
+        }
+    }
+    notifyCameraDeleted(cameraId, pluginId) {
+        // Drop plugin's source cache so the next scan rediscovers the camera fresh.
+        if (pluginId) {
+            const sourceId = `plugin-${pluginId}`;
+            this.sourceCache.delete(sourceId);
+        }
+        if (this.subscriberCount > 0) {
+            this.publishDiscoveryEvent('cameras:deleted', { cameraId, pluginId });
+        }
+    }
+    notifyCameraUpdated(cameraId) {
+        const cc = this.api.getCameras().find((c) => c.id === cameraId);
+        if (!cc)
+            return;
+        const hasPlugin = !!cc.pluginInfo?.id;
+        const updatedDevice = {
+            id: cc.id,
+            name: cc.name,
+            manufacturer: cc.info?.manufacturer,
+            model: cc.info?.model,
+            provider: hasPlugin ? (cc.pluginInfo?.name ?? 'camera.ui') : 'camera.ui',
+            room: cc.room,
+            status: 'added',
+            type: 'camera',
+            cameraId: cc.id,
+        };
+        if (this.subscriberCount > 0) {
+            this.broadcastDiscovered([updatedDevice], 'database');
+        }
+    }
+    getDiscoveryPlugins() {
+        return this.pluginsService.listPlugins().filter((plugin) => isDiscoveryProvider(plugin.contract) && plugin.worker?.isRunning());
+    }
+    fetchDbCameras() {
+        const cameraControllers = this.api.getCameras();
+        const devices = [];
+        for (const cc of cameraControllers) {
+            const hasPlugin = !!cc.pluginInfo?.id;
+            devices.push({
+                id: cc.id,
+                name: cc.name,
+                manufacturer: cc.info?.manufacturer,
+                model: cc.info?.model,
+                provider: hasPlugin ? (cc.pluginInfo?.name ?? 'camera.ui') : 'camera.ui',
+                room: cc.room,
+                status: 'added',
+                type: 'camera',
+                cameraId: cc.id,
+            });
+        }
+        return devices;
+    }
+    async fetchGo2rtcCameras() {
+        try {
+            const { sources } = await this.go2rtcApi.discoverRoute.discoverSources();
+            return this.convertGo2rtcSources(sources);
+        }
+        catch {
+            return [];
+        }
+    }
+    async fetchPluginCameras(pluginId) {
+        const plugin = this.pluginsService.getPluginById(pluginId);
+        if (!plugin?.worker?.isRunning()) {
+            return [];
+        }
+        try {
+            const cameras = await plugin.worker.pluginProxy.onDiscoverCameras?.();
+            if (!cameras) {
+                return [];
+            }
+            const result = cameras.map((c) => ({ ...c, provider: pluginId }));
+            for (const camera of result) {
+                this.discoveredCamerasCache.set(camera.id, camera);
+            }
+            return result;
+        }
+        catch (error) {
+            this.logger.debug(`[Discovery] Plugin ${plugin.pluginName} scan failed:`, error);
+            return [];
+        }
+    }
+    updateSourceCache(sourceId, cameras, error) {
+        this.sourceCache.set(sourceId, {
+            sourceId,
+            cameras,
+            lastScannedAt: Date.now(),
+            scanDurationMs: 0,
+            error,
+        });
+        for (const camera of cameras) {
+            this.discoveredCamerasCache.set(camera.id, camera);
+        }
+    }
+    cleanupOrphanedCameras(activeSources) {
+        for (const sourceId of this.sourceCache.keys()) {
+            if (!activeSources.has(sourceId)) {
+                const entry = this.sourceCache.get(sourceId);
+                if (entry) {
+                    for (const camera of entry.cameras) {
+                        this.discoveredCamerasCache.delete(camera.id);
+                    }
+                }
+                this.sourceCache.delete(sourceId);
+            }
+        }
+    }
+    mergeResults() {
+        const devices = [];
+        const seenIds = new Set();
+        const dbCameras = this.fetchDbCameras();
+        for (const camera of dbCameras) {
+            if (!seenIds.has(camera.id)) {
+                seenIds.add(camera.id);
+                devices.push(camera);
+            }
+        }
+        for (const [, entry] of this.sourceCache) {
+            for (const camera of entry.cameras) {
+                if (!seenIds.has(camera.id)) {
+                    seenIds.add(camera.id);
+                    devices.push(this.toDeviceListItem(camera));
+                }
+            }
+        }
+        devices.sort((a, b) => {
+            if (a.type !== b.type) {
+                return a.type === 'camera' ? -1 : 1;
+            }
+            return a.name.localeCompare(b.name);
+        });
+        return devices;
+    }
+    toDeviceListItem(camera) {
+        const connectionState = this.connectionStates.get(camera.id);
+        let status = 'discovered';
+        if (connectionState?.status === 'connecting') {
+            status = 'adopting';
+        }
+        else if (connectionState?.status === 'error') {
+            status = 'error';
+        }
+        const isGo2rtc = camera.provider === 'go2rtc';
+        return {
+            id: camera.id,
+            name: camera.name,
+            manufacturer: camera.manufacturer,
+            model: camera.model,
+            provider: isGo2rtc ? 'camera.ui' : this.formatPluginName(camera.provider),
+            status,
+            errorMessage: connectionState?.errorMessage,
+            type: 'discovered',
+            discoveredId: camera.id,
+        };
+    }
+    findDiscoveredCamera(discoveredId) {
+        const camera = this.discoveredCamerasCache.get(discoveredId);
+        if (camera) {
+            const plugin = this.pluginsService.getPluginById(camera.provider);
+            return { plugin: plugin ?? null, camera };
+        }
+        return { plugin: null, camera: null };
+    }
+    formatPluginName(pluginId) {
+        const plugin = this.pluginsService.getPluginById(pluginId);
+        if (plugin) {
+            return plugin.pluginName;
+        }
+        const name = pluginId.replace(/^camera-ui-/, '').replace(/-/g, ' ');
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    convertGo2rtcSources(sources) {
+        return sources.map((source) => {
+            const { address } = this.parseUrl(source.url);
+            // go2rtc ONVIF: name=IP, info="DeviceName Hardware" (may be duplicated like "C210 C210").
+            // go2rtc HomeKit: name=actual name, info=model. Prefer info-derived name over IP.
+            let displayName = source.name ?? address;
+            let model = source.info ?? '';
+            if (source.info && source.name && this.looksLikeAddress(source.name)) {
+                // Deduplicate repeated words (e.g. "C210 C210" → "C210").
+                const words = source.info.trim().split(/\s+/);
+                const uniqueWords = [...new Set(words)];
+                displayName = uniqueWords.join(' ') || source.name;
+                model = uniqueWords.join(' ');
+            }
+            return {
+                id: `go2rtc:${source.type.toLowerCase()}:${source.id ?? address}`,
+                name: displayName,
+                manufacturer: source.type,
+                model,
+                provider: 'go2rtc',
+                _internalAddress: address,
+                _originalUrl: source.url,
+            };
+        });
+    }
+    looksLikeAddress(value) {
+        return /^[\d.:[\]]+$/.test(value) || /^\d+\.\d+\.\d+\.\d+(:\d+)?$/.test(value);
+    }
+    extractAddressFromDbCamera(camera) {
+        const cc = this.api.getCameras().find((c) => c.id === camera.cameraId);
+        if (!cc)
+            return undefined;
+        return this.extractAddressFromSources(cc.sources);
+    }
+    extractAddressFromSources(sources) {
+        if (!sources || sources.length === 0)
+            return undefined;
+        for (const source of sources) {
+            const rtspUrl = source.urls?.rtsp?.base;
+            if (rtspUrl) {
+                const { address } = this.parseUrl(rtspUrl);
+                if (address && address !== 'localhost' && address !== '127.0.0.1') {
+                    return address;
+                }
+            }
+        }
+        return undefined;
+    }
+    parseUrl(url) {
+        try {
+            const parsed = new URL(url);
+            return { address: parsed.hostname };
+        }
+        catch {
+            const regex = /^(?:\w+:\/\/)?([^:/]+)/;
+            const match = regex.exec(url);
+            return { address: match?.[1] ?? url };
+        }
+    }
+    logDiscoverySummary() {
+        const dbCount = this.fetchDbCameras().length;
+        let discoveredCount = 0;
+        for (const [sourceId, entry] of this.sourceCache) {
+            if (sourceId !== 'database') {
+                discoveredCount += entry.cameras.length;
+            }
+        }
+        if (!this.initialScanLogged) {
+            this.initialScanLogged = true;
+            this.logger.log(`[Discovery] Scan complete: ${dbCount} camera(s), ${discoveredCount} discovered camera(s)`);
+        }
+    }
+    getGo2rtcCameraSettings(discoveredId) {
+        const parts = discoveredId.split(':');
+        const type = parts[1]?.toLowerCase();
+        const schema = [];
+        if (type === 'onvif' || type === 'dvrip') {
+            schema.push({ key: 'username', type: 'string', title: 'Username', description: 'Camera username', required: true }, { key: 'password', type: 'string', title: 'Password', description: 'Camera password', format: 'password', required: true });
+        }
+        else if (type === 'homekit') {
+            schema.push({ key: 'pin', type: 'string', title: 'PIN', description: 'HomeKit pairing PIN (e.g., 123-45-678)', required: true });
+        }
+        // hass and gopro require no credentials → empty schema.
+        return schema;
+    }
+    async adoptGo2rtcCamera(discoveredId, cameraSettings) {
+        const parts = discoveredId.split(':');
+        const type = parts[1]?.toLowerCase();
+        const cached = this.discoveredCamerasCache.get(discoveredId);
+        if (!cached?._originalUrl) {
+            throw new Error(`Discovered camera "${discoveredId}" not found in cache. Try rescanning.`);
+        }
+        let cameraName = cached.name;
+        let sources;
+        switch (type) {
+            case 'onvif': {
+                const result = await this.adoptOnvifCamera(cached._originalUrl, cameraSettings);
+                cameraName = result.name || cameraName;
+                sources = result.sources;
+                break;
+            }
+            case 'homekit': {
+                const result = await this.adoptHomeKitCamera(cached._originalUrl, cameraSettings);
+                cameraName = result.name || cameraName;
+                sources = result.sources;
+                break;
+            }
+            case 'dvrip': {
+                const result = await this.adoptDVRipCamera(cached._originalUrl, cameraSettings, cameraName);
+                cameraName = result.name;
+                sources = result.sources;
+                break;
+            }
+            case 'hass':
+            case 'gopro': {
+                sources = [
+                    {
+                        name: 'Stream 1',
+                        role: 'high-resolution',
+                        urls: [cached._originalUrl],
+                        useForSnapshot: true,
+                        hotMode: false,
+                        preload: false,
+                        prebuffer: false,
+                    },
+                ];
+                break;
+            }
+            default:
+                throw new Error(`Unsupported go2rtc camera type: ${type}`);
+        }
+        const validatedData = createCameraSchema.parse({
+            name: cameraName,
+            sources,
+            info: {
+                manufacturer: cached.manufacturer,
+                model: cached.model,
+            },
+        });
+        const dbCamera = await this.camerasService.createCamera(validatedData);
+        const newCameraDevice = {
+            id: dbCamera._id,
+            name: dbCamera.name,
+            manufacturer: cached.manufacturer,
+            model: cached.model,
+            provider: 'camera.ui',
+            room: dbCamera.room,
+            status: 'added',
+            type: 'camera',
+            cameraId: dbCamera._id,
+        };
+        this.broadcastDiscovered([newCameraDevice], 'database');
+        return {
+            cameraId: dbCamera._id,
+            cameraName: dbCamera.name,
+        };
+    }
+    async adoptOnvifCamera(originalUrl, settings) {
+        const { username, password } = settings;
+        const url = new URL(originalUrl);
+        url.username = username;
+        url.password = password;
+        const authenticatedUrl = url.toString();
+        const { sources: profiles } = await this.go2rtcApi.discoverRoute.discoverOnvif({ src: authenticatedUrl });
+        if (!profiles.length) {
+            throw new Error('No ONVIF streams found. Check credentials.');
+        }
+        const snapshotProfile = profiles.find((p) => p.id === 'snapshot');
+        const videoProfiles = profiles
+            .filter((p) => p.id !== 'snapshot')
+            .sort((a, b) => {
+            const numA = parseInt(a.id.replace('stream', ''), 10) || 99;
+            const numB = parseInt(b.id.replace('stream', ''), 10) || 99;
+            return numA - numB;
+        });
+        if (!videoProfiles.length) {
+            throw new Error('No ONVIF video streams found');
+        }
+        // go2rtc encodes profile names as "DeviceName stream1"; strip the suffix.
+        const cameraName = videoProfiles[0]?.name?.replace(/\s+stream\d+$/i, '').trim() || 'ONVIF Camera';
+        const sources = [];
+        // Role mapping: 1 stream → high; 2 streams → high+low; 3+ streams → high+mid+low (max 3).
+        videoProfiles.slice(0, 3).forEach((profile, index) => {
+            let role;
+            if (index === 0) {
+                role = 'high-resolution';
+            }
+            else if (videoProfiles.length === 2) {
+                role = 'low-resolution';
+            }
+            else if (index === 1) {
+                role = 'mid-resolution';
+            }
+            else {
+                role = 'low-resolution';
+            }
+            sources.push({
+                // Use simple names; go2rtc profile.name usually duplicates the camera name in the path.
+                name: `Stream ${index + 1}`,
+                role,
+                urls: [profile.url],
+                useForSnapshot: index === 0 && !snapshotProfile,
+                // hotMode/preload disabled: numeric ONVIF profile tokens trigger "wrong subtype" on eager connect.
+                hotMode: false,
+                preload: false,
+                prebuffer: false,
+            });
+        });
+        if (snapshotProfile) {
+            sources.push({
+                name: 'Snapshot',
+                role: 'snapshot',
+                urls: [snapshotProfile.url],
+                hotMode: false,
+                preload: false,
+                prebuffer: false,
+            });
+        }
+        return { name: cameraName, sources };
+    }
+    async adoptHomeKitCamera(originalUrl, settings) {
+        const { pin } = settings;
+        const url = new URL(originalUrl);
+        const deviceId = url.searchParams.get('device_id') ?? 'homekit';
+        const pairResult = await this.go2rtcApi.streamsRoute.pairHomekit({
+            id: deviceId.replace(/:/g, ''),
+            url: originalUrl,
+            pin,
+        });
+        const sources = [
+            {
+                name: 'Stream 1',
+                role: 'high-resolution',
+                urls: [pairResult.source.url],
+                useForSnapshot: true,
+                hotMode: false,
+                preload: false,
+                prebuffer: false,
+            },
+        ];
+        return {
+            name: pairResult.source.name || 'HomeKit Camera',
+            sources,
+        };
+    }
+    async adoptDVRipCamera(originalUrl, settings, cameraName) {
+        const { username, password } = settings;
+        // Format: dvrip://username:password@host?channel=0&subtype=0
+        const url = new URL(originalUrl);
+        url.username = username;
+        url.password = password;
+        if (!url.searchParams.has('channel')) {
+            url.searchParams.set('channel', '0');
+        }
+        if (!url.searchParams.has('subtype')) {
+            url.searchParams.set('subtype', '0');
+        }
+        const authenticatedUrl = url.toString();
+        const sources = [
+            {
+                name: 'Stream 1',
+                role: 'high-resolution',
+                urls: [authenticatedUrl],
+                useForSnapshot: true,
+                hotMode: false,
+                preload: false,
+                prebuffer: false,
+            },
+        ];
+        return { name: cameraName, sources };
+    }
+    async adoptPluginCamera(discoveredId, cameraSettings) {
+        const { plugin, camera } = this.findDiscoveredCamera(discoveredId);
+        if (!plugin || !camera) {
+            throw new Error(`Camera "${discoveredId}" not found`);
+        }
+        if (!plugin.worker?.isRunning()) {
+            throw new Error(`Plugin "${plugin.pluginName}" is not running`);
+        }
+        const cameraConfig = await plugin.worker.pluginProxy.onAdoptCamera?.(camera, cameraSettings);
+        if (!cameraConfig) {
+            throw new Error(`Plugin "${plugin.pluginName}" does not support camera adoption`);
+        }
+        if (!cameraConfig.sources.length) {
+            throw new Error(`Camera "${cameraConfig.name}" must have at least one source`);
+        }
+        cameraConfig.sources = cameraConfig.sources.map((source) => {
+            if (!source.urls?.length) {
+                source.urls = ['cui://127.0.0.1'];
+            }
+            return source;
+        });
+        const validatedData = createCameraSchema.parse({
+            ...cameraConfig,
+            pluginInfo: {
+                id: plugin.id,
+                name: plugin.pluginName,
+            },
+        });
+        validatedData.sources = validatedData.sources.map((source) => {
+            if (source.urls.length === 1 && source.urls[0].startsWith('cui://')) {
+                source.urls = [`cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${validatedData._id}/${source.name}`];
+            }
+            return source;
+        });
+        const dbCamera = await this.camerasService.createCamera(validatedData);
+        const pluginNamespaces = NamespaceManager.pluginNamespaces(plugin.id);
+        const transformedCamera = this.camerasService.transformCamera(dbCamera);
+        await this.proxyServer.proxy.publish(pluginNamespaces.pluginDeviceManagerSubject, {
+            type: 'cameraAdded',
+            data: { camera: transformedCamera },
+        });
+        const newCameraDevice = {
+            id: dbCamera._id,
+            name: dbCamera.name,
+            manufacturer: dbCamera.info?.manufacturer,
+            model: dbCamera.info?.model,
+            provider: plugin.pluginName,
+            room: dbCamera.room,
+            status: 'added',
+            type: 'camera',
+            cameraId: dbCamera._id,
+        };
+        this.broadcastDiscovered([newCameraDevice], 'database');
+        return {
+            cameraId: dbCamera._id,
+            cameraName: dbCamera.name,
+        };
+    }
+    setConnectionState(discoveredId, status, errorMessage) {
+        this.connectionStates.set(discoveredId, { status, errorMessage });
+    }
+    removeFromDiscoveredCache(discoveredId) {
+        this.discoveredCamerasCache.delete(discoveredId);
+        for (const [sourceId, entry] of this.sourceCache) {
+            const index = entry.cameras.findIndex((c) => c.id === discoveredId);
+            if (index !== -1) {
+                entry.cameras.splice(index, 1);
+                this.sourceCache.set(sourceId, entry);
+                break;
+            }
+        }
+        this.connectionStates.delete(discoveredId);
+    }
+    broadcastDiscovered(devices, source) {
+        this.publishDiscoveryEvent('cameras:discovered', { devices, source });
+    }
+    broadcastScanningStatus(isScanning) {
+        this.publishDiscoveryEvent('cameras:scanning', { isScanning });
+    }
+    broadcastConnectionStatus(discoveredId) {
+        const state = this.connectionStates.get(discoveredId) ?? { status: 'idle' };
+        this.publishDiscoveryEvent('cameras:connection-status', {
+            discoveredId,
+            status: state.status,
+            errorMessage: state.errorMessage,
+        });
+    }
+    publishDiscoveryEvent(type, data) {
+        const event = { type, data };
+        this.proxyServer.proxy.publish(this.namespaces.discoveryManagerSubject, event);
+    }
+};
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", Promise)
+], DiscoveryManager.prototype, "pushDiscoveredCameras", null);
+DiscoveryManager = __decorate([
+    RPCClass,
+    __metadata("design:paramtypes", [])
+], DiscoveryManager);
+export { DiscoveryManager };
+//# sourceMappingURL=discoveryManager.js.map