@apocaliss92/scrypted-mjpeg-rebroadcast 0.0.1

package/.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Scrypted Debugger",
+            "address": "${config:scrypted.debugHost}",
+            "port": 10081,
+            "request": "attach",
+            "skipFiles": [
+                "**/plugin-remote-worker.*",
+                "<node_internals>/**"
+            ],
+            "preLaunchTask": "scrypted: deploy+debug",
+            "sourceMaps": true,
+            "localRoot": "${workspaceFolder}/out",
+            "remoteRoot": "/plugin/",
+            "type": "node"
+        }
+    ]
+}

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+
+{
+    "scrypted.debugHost": "192.168.1.4",
+}

package/.vscode/tasks.json

@@ -0,0 +1,20 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "scrypted: deploy+debug",
+            "type": "shell",
+            "presentation": {
+                "echo": true,
+                "reveal": "silent",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": true,
+                "clear": false
+            },
+            "command": "npm run scrypted-vscode-launch ${config:scrypted.debugHost}",
+        },
+    ]
+}

package/README.md

@@ -0,0 +1,8 @@
+# Scrypted MJPEG Rebroadcast
+
+☕️ If this extension works well for you, consider buying me a coffee. Thanks!
+[Buy me a coffee!](https://buymeacoffee.com/apocaliss92)
+
+**Documentation:** [https://advanced-notifier-docs.zentik.app/docs/mjpeg-rebroadcast](https://advanced-notifier-docs.zentik.app/docs/mjpeg-rebroadcast)
+
+[For requests and bugs](https://github.com/apocaliss92/scrypted-mjpeg-rebroadcast)

package/package.json

@@ -0,0 +1,49 @@
+{
+   "name": "@apocaliss92/scrypted-mjpeg-rebroadcast",
+   "description": "Scrypted mixin plugin for MJPEG live stream rebroadcast per camera",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/apocaliss92/scrypted-mjpeg-rebroadcast"
+   },
+   "version": "0.0.1",
+   "scripts": {
+      "scrypted-setup-project": "scrypted-setup-project",
+      "prescrypted-setup-project": "scrypted-package-json",
+      "build": "scrypted-webpack",
+      "prepublishOnly": "NODE_ENV=production scrypted-webpack",
+      "prescrypted-vscode-launch": "scrypted-webpack",
+      "scrypted-vscode-launch": "scrypted-deploy-debug",
+      "scrypted-deploy-debug": "scrypted-deploy-debug",
+      "scrypted-debug": "scrypted-debug",
+      "scrypted-deploy": "scrypted-deploy",
+      "scrypted-readme": "scrypted-readme",
+      "scrypted-package-json": "scrypted-package-json"
+   },
+   "keywords": [
+      "scrypted",
+      "plugin",
+      "mjpeg",
+      "rebroadcast",
+      "camera",
+      "snapshot",
+      "mixin"
+   ],
+   "scrypted": {
+      "name": "MJPEG Rebroadcast",
+      "type": "API",
+      "interfaces": [
+         "Settings",
+         "MixinProvider",
+         "HttpRequestHandler"
+      ],
+      "pluginDependencies": []
+   },
+   "dependencies": {
+      "@scrypted/sdk": "0.5.53",
+      "lodash": "^4.17.21"
+   },
+   "devDependencies": {
+      "@types/lodash": "^4.17.12",
+      "@types/node": "^20.11.0"
+   }
+}

package/polyfill/admzip.js

@@ -0,0 +1 @@
+const admzip = __non_webpack_require__('adm-zip'); module.exports = admzip;

package/polyfill/fakefs.js

@@ -0,0 +1 @@
+const fakefs = __non_webpack_require__('fakefs'); module.exports = fakefs;

package/polyfill/mdns.js

@@ -0,0 +1 @@
+const mdns = __non_webpack_require__('mdns'); module.exports = mdns;

package/polyfill/memfs.js

@@ -0,0 +1 @@
+const memfs = __non_webpack_require__('memfs'); module.exports = memfs;

package/polyfill/nodeforge.js

@@ -0,0 +1 @@
+const nodeforge = __non_webpack_require__('node-forge'); module.exports = nodeforge;

package/polyfill/nodeptyprebuiltmultiarch.js

@@ -0,0 +1 @@
+const nodeptyprebuiltmultiarch = __non_webpack_require__('node-pty-prebuilt-multiarch'); module.exports = nodeptyprebuiltmultiarch;

package/polyfill/realfs.js

@@ -0,0 +1 @@
+const realfs = __non_webpack_require__('realfs'); module.exports = realfs;

package/polyfill/scryptednodepty.js

@@ -0,0 +1 @@
+const scryptednodepty = __non_webpack_require__('@scrypted/node-pty'); module.exports = scryptednodepty;

package/polyfill/sharp.js

@@ -0,0 +1 @@
+const sharp = __non_webpack_require__('sharp'); module.exports = sharp;

package/polyfill/sourcemapsupportregister.js

@@ -0,0 +1 @@
+const sourcemapsupportregister = __non_webpack_require__('source-map-support/register'); module.exports = sourcemapsupportregister;

package/polyfill/typescript.js

@@ -0,0 +1 @@
+const typescript = __non_webpack_require__('typescript'); module.exports = typescript;

package/src/cameraMixin.ts

@@ -0,0 +1,443 @@
+import sdk, { Setting, SettingValue, Settings } from '@scrypted/sdk';
+import { SettingsMixinDeviceBase, SettingsMixinDeviceOptions } from '@scrypted/sdk/settings-mixin';
+import { StorageSettings } from '@scrypted/sdk/storage-settings';
+import { MjpegProducer } from './mjpegProducer';
+import { FrameHub } from './frameHub';
+import { MjpegSourceEnum } from './types';
+import crypto from 'crypto';
+
+import type MjpegRebroadcastPlugin from './main';
+
+const { systemManager } = sdk;
+
+interface StreamInfo {
+    name: string;
+    rtspUrl: string;
+    /** Path token extracted from the RTSP rebroadcast URL (already secret) */
+    pathToken: string;
+}
+
+/**
+ * Extract the path segment from an RTSP URL to use as stream token.
+ * e.g. rtsp://192.168.1.4:38911/abc123 → abc123
+ */
+function extractPathToken(rtspUrl: string): string {
+    try {
+        const url = new URL(rtspUrl);
+        return url.pathname.replace(/^\//, '');
+    } catch {
+        return crypto.randomBytes(16).toString('hex');
+    }
+}
+
+/** Force-restart FFmpeg after this duration regardless of clients */
+const MAX_RUNTIME_MS = 4 * 60 * 60 * 1000; // 4 hours
+/** Restart FFmpeg early if 0 clients for this long (prebuffer only) */
+const IDLE_RESTART_MS = 30 * 60 * 1000; // 30 minutes
+/** How often to check producer health */
+const HEALTH_CHECK_INTERVAL_MS = 60 * 1000; // 1 minute
+
+export class MjpegRebroadcastCameraMixin extends SettingsMixinDeviceBase<any> {
+    plugin: MjpegRebroadcastPlugin;
+    private logger: {
+        log: (...args: any[]) => void;
+        debug: (...args: any[]) => void;
+        warn: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+    private producers: Map<string, MjpegProducer> = new Map();
+    private producerStartedAt: Map<string, number> = new Map();
+    private discoveredStreams: StreamInfo[] = [];
+    private healthCheckInterval: NodeJS.Timeout | null = null;
+    killed = false;
+
+    /** Per-stream frame hubs — keyed by pathToken */
+    frameHubs: Map<string, FrameHub> = new Map();
+    /** Maps pathToken → stream name (for status/display) */
+    tokenToName: Map<string, string> = new Map();
+
+    storageSettings = new StorageSettings(this, {
+        mjpegSource: {
+            title: 'MJPEG source',
+            description: 'Choose how to generate the MJPEG streams',
+            type: 'string',
+            choices: [
+                MjpegSourceEnum.ScryptedSnapshot,
+                MjpegSourceEnum.ScryptedRtspFfmpeg,
+            ],
+            defaultValue: MjpegSourceEnum.ScryptedRtspFfmpeg,
+            immediate: true,
+        },
+        fps: {
+            title: 'FPS',
+            description: 'Target frames per second',
+            type: 'number',
+            defaultValue: 5,
+        },
+        quality: {
+            title: 'Quality',
+            description: 'JPEG quality (1-100)',
+            type: 'number',
+            defaultValue: 80,
+        },
+        width: {
+            title: 'Width',
+            description: 'Output width (blank for original). Height is auto-calculated.',
+            type: 'number',
+        },
+        prebufferStreams: {
+            title: 'Prebuffer streams',
+            description: 'Selected streams will have FFmpeg always running (instant playback). Others start on-demand when a client connects.',
+            type: 'string',
+            multiple: true,
+            choices: [],
+            immediate: true,
+            onPut: async () => {
+                if (this.storageSettings.values.serverEnabled) {
+                    await this.setupStreams();
+                }
+            },
+        },
+        serverEnabled: {
+            title: 'MJPEG server enabled',
+            type: 'boolean',
+            defaultValue: true,
+            immediate: true,
+            onPut: async (_oldValue, newValue) => {
+                if (newValue) {
+                    await this.discoverStreams();
+                    await this.setupStreams();
+                } else {
+                    await this.teardownStreams();
+                }
+            },
+        },
+        debugEvents: {
+            title: 'Debug logging',
+            description: 'Enable verbose debug logging',
+            type: 'boolean',
+            defaultValue: false,
+            immediate: true,
+        },
+    });
+
+    constructor(
+        options: SettingsMixinDeviceOptions<any>,
+        plugin: MjpegRebroadcastPlugin,
+    ) {
+        super(options);
+        this.plugin = plugin;
+        this.plugin.currentMixinsMap[this.id] = this;
+        this.logger = {
+            log: (message: string, ...args: any[]) =>
+                this.console.log(message, ...args),
+            debug: (message: string, ...args: any[]) => {
+                if (this.storageSettings.values.debugEvents)
+                    this.console.log(`[DEBUG] ${message}`, ...args);
+            },
+            warn: (message: string, ...args: any[]) =>
+                this.console.warn(message, ...args),
+            error: (message: string, ...args: any[]) =>
+                this.console.error(message, ...args),
+        };
+
+        setTimeout(() => this.init(), 5000);
+    }
+
+    get activeStreamTokens(): string[] {
+        return Array.from(this.frameHubs.keys());
+    }
+
+    private async init() {
+        if (this.killed) return;
+
+        this.console.log(`MJPEG Rebroadcast mixin initialized for ${this.name}`);
+
+        await this.discoverStreams();
+
+        if (this.killed) return;
+
+        if (this.storageSettings.values.serverEnabled) {
+            await this.setupStreams();
+        }
+    }
+
+    async getMixinSettings(): Promise<Setting[]> {
+        const mjpegSource = this.storageSettings.values.mjpegSource;
+        const isSnapshot = mjpegSource === MjpegSourceEnum.ScryptedSnapshot;
+
+        this.storageSettings.settings.width.hide = isSnapshot;
+        this.storageSettings.settings.quality.hide = isSnapshot;
+        this.storageSettings.settings.prebufferStreams.hide = isSnapshot;
+
+        if (this.discoveredStreams.length > 0) {
+            this.storageSettings.settings.prebufferStreams.choices = this.discoveredStreams.map(s => s.name);
+        }
+
+        const settings = await this.storageSettings.getSettings();
+
+        if (this.frameHubs.size > 0) {
+            try {
+                const baseEndpoint = await this.plugin.getEndpointUrl();
+
+                for (const [token] of this.frameHubs) {
+                    const streamName = this.tokenToName.get(token) ?? token;
+                    const url = `${baseEndpoint}/${token}`;
+                    settings.push({
+                        key: `streamUrl_${token}`,
+                        title: `MJPEG Stream Url (${streamName})`,
+                        description: url,
+                        value: url,
+                        type: 'string',
+                        readonly: true,
+                        subgroup: 'Stream URLs',
+                    });
+                }
+            } catch (e) {
+                this.logger.debug(`Could not generate stream URLs: ${(e as Error).message}`);
+            }
+        }
+
+        return settings;
+    }
+
+    async putMixinSetting(key: string, value: SettingValue): Promise<void> {
+        await this.storageSettings.putSetting(key, value);
+    }
+
+    private async discoverStreams() {
+        this.discoveredStreams = [];
+
+        try {
+            const device = systemManager.getDeviceById(this.id) as unknown as Settings;
+            if (!device?.getSettings) return;
+
+            const deviceSettings = await device.getSettings();
+            const rtspSettings = deviceSettings.filter(
+                (setting) => setting.title === 'RTSP Rebroadcast Url',
+            );
+
+            for (const setting of rtspSettings) {
+                const rtspUrl = setting.value as string;
+                if (!rtspUrl) continue;
+
+                const streamName = setting.subgroup?.replace('Stream: ', '') ?? 'Default';
+                const pathToken = extractPathToken(rtspUrl);
+                this.discoveredStreams.push({
+                    name: streamName,
+                    rtspUrl,
+                    pathToken,
+                });
+            }
+
+            this.logger.debug(`${this.name}: found ${this.discoveredStreams.length} RTSP stream(s)`);
+            for (const s of this.discoveredStreams) {
+                this.logger.debug(`  - ${s.name}: ${s.rtspUrl} (token: ${s.pathToken})`);
+            }
+        } catch (e) {
+            this.console.warn(`Failed to discover streams for ${this.name}: ${(e as Error).message}`);
+        }
+    }
+
+    private getPrebufferStreamNames(): Set<string> {
+        const names = this.storageSettings.values.prebufferStreams as string[] | undefined;
+        return new Set(names ?? []);
+    }
+
+    /**
+     * Start a producer for a specific stream token.
+     * Called lazily when the first client subscribes.
+     * Returns a promise that resolves when the producer is ready.
+     */
+    private async startProducer(token: string) {
+        if (this.producers.has(token)) return; // Already running
+
+        const fps = (this.storageSettings.values.fps as number) || 5;
+        const quality = (this.storageSettings.values.quality as number) || 80;
+        const width = this.storageSettings.values.width as number;
+        const mjpegSource = this.storageSettings.values.mjpegSource;
+        const hub = this.frameHubs.get(token);
+        if (!hub) return;
+
+        const streamName = this.tokenToName.get(token) ?? token;
+        const prebufferNames = this.getPrebufferStreamNames();
+        const isPrebuffer = prebufferNames.has(streamName);
+        this.console.log(`${this.name}: starting producer for "${streamName}" (${isPrebuffer ? 'prebuffer' : 'first client connected'})`);
+
+        const producer = new MjpegProducer(this.console);
+        producer.debugLog = (message, ...args) => this.logger.debug(message, ...args);
+        producer.onFrame = (frame) => hub.push(frame);
+        this.producers.set(token, producer);
+        this.producerStartedAt.set(token, Date.now());
+
+        try {
+            if (mjpegSource === MjpegSourceEnum.ScryptedSnapshot) {
+                await producer.startSnapshotPolling(this.id, fps);
+            } else {
+                const stream = this.discoveredStreams.find(s => s.pathToken === token);
+                if (stream) {
+                    await producer.startRtspToMjpeg(stream.rtspUrl, fps, quality, width);
+                }
+            }
+        } catch (e) {
+            this.console.error(`Failed to start producer for ${streamName}: ${(e as Error).message}`);
+        }
+    }
+
+    /**
+     * Stop a producer for a specific stream token.
+     * Called when the last client disconnects.
+     */
+    private stopProducer(token: string) {
+        const producer = this.producers.get(token);
+        if (!producer) return;
+
+        const streamName = this.tokenToName.get(token) ?? token;
+        this.console.log(`${this.name}: stopping producer for "${streamName}" (no more clients)`);
+
+        producer.stop();
+        this.producers.delete(token);
+        this.producerStartedAt.delete(token);
+    }
+
+    /**
+     * Restart a running producer (stop + start).
+     * For prebuffer streams this is seamless; for on-demand it only restarts if clients are connected.
+     */
+    private async restartProducer(token: string) {
+        const producer = this.producers.get(token);
+        if (!producer) return;
+
+        const streamName = this.tokenToName.get(token) ?? token;
+        this.console.log(`${this.name}: restarting producer for "${streamName}"`);
+
+        producer.stop();
+        this.producers.delete(token);
+        this.producerStartedAt.delete(token);
+
+        await this.startProducer(token);
+    }
+
+    /**
+     * Periodic health check: restarts producers that have been running too long
+     * or that are idle (prebuffer with 0 clients).
+     */
+    private checkProducerHealth() {
+        if (this.killed) return;
+
+        const now = Date.now();
+        const prebufferNames = this.getPrebufferStreamNames();
+
+        for (const [token] of this.producers) {
+            const startedAt = this.producerStartedAt.get(token);
+            if (!startedAt) continue;
+
+            const runtime = now - startedAt;
+            const hub = this.frameHubs.get(token);
+            const subscribers = hub?.subscriberCount ?? 0;
+            const streamName = this.tokenToName.get(token) ?? token;
+            const isPrebuffer = prebufferNames.has(streamName);
+
+            if (runtime >= MAX_RUNTIME_MS) {
+                this.console.log(`${this.name}: "${streamName}" max runtime reached (${Math.round(runtime / 60000)}min), restarting`);
+                this.restartProducer(token);
+            } else if (isPrebuffer && subscribers === 0 && runtime >= IDLE_RESTART_MS) {
+                this.console.log(`${this.name}: "${streamName}" idle with 0 clients for ${Math.round(runtime / 60000)}min, restarting`);
+                this.restartProducer(token);
+            }
+        }
+    }
+
+    /**
+     * Set up FrameHubs for ALL discovered streams.
+     * Prebuffer streams start FFmpeg immediately; others start lazily on first client.
+     */
+    private async setupStreams() {
+        await this.teardownStreams();
+
+        if (this.discoveredStreams.length === 0 && this.storageSettings.values.mjpegSource === MjpegSourceEnum.ScryptedRtspFfmpeg) {
+            this.logger.debug(`No streams found for ${this.name}, trying to discover...`);
+            await this.discoverStreams();
+        }
+
+        const mjpegSource = this.storageSettings.values.mjpegSource;
+        const prebufferNames = this.getPrebufferStreamNames();
+
+        try {
+            if (mjpegSource === MjpegSourceEnum.ScryptedSnapshot) {
+                const token = crypto.randomBytes(16).toString('hex');
+                const hub = new FrameHub();
+                hub.onFirstSubscriber = () => this.startProducer(token);
+                hub.onLastUnsubscribe = () => this.stopProducer(token);
+                this.frameHubs.set(token, hub);
+                this.tokenToName.set(token, 'Snapshot');
+
+                this.console.log(`${this.name}: MJPEG snapshot endpoint ready (on-demand)`);
+            } else if (mjpegSource === MjpegSourceEnum.ScryptedRtspFfmpeg) {
+                if (this.discoveredStreams.length === 0) {
+                    this.console.warn(`No RTSP streams found for ${this.name}. Make sure the Rebroadcast plugin is installed.`);
+                    return;
+                }
+
+                const prebufferTokens: string[] = [];
+
+                for (const stream of this.discoveredStreams) {
+                    const isPrebuffer = prebufferNames.has(stream.name);
+                    const hub = new FrameHub();
+
+                    if (isPrebuffer) {
+                        // Prebuffer: no lazy lifecycle — producer starts immediately
+                        hub.onFirstSubscriber = null;
+                        hub.onLastUnsubscribe = null;
+                    } else {
+                        // On-demand: lazy start/stop
+                        hub.onFirstSubscriber = () => this.startProducer(stream.pathToken);
+                        hub.onLastUnsubscribe = () => this.stopProducer(stream.pathToken);
+                    }
+
+                    this.frameHubs.set(stream.pathToken, hub);
+                    this.tokenToName.set(stream.pathToken, stream.name);
+
+                    if (isPrebuffer) {
+                        prebufferTokens.push(stream.pathToken);
+                    }
+                }
+
+                // Start prebuffer producers immediately
+                for (const token of prebufferTokens) {
+                    await this.startProducer(token);
+                }
+
+                const onDemandCount = this.discoveredStreams.length - prebufferTokens.length;
+                this.console.log(`${this.name}: ${this.discoveredStreams.length} MJPEG endpoint(s) ready (${prebufferTokens.length} prebuffer, ${onDemandCount} on-demand)`);
+            }
+
+            // Start periodic health check for producer restarts
+            this.healthCheckInterval = setInterval(() => this.checkProducerHealth(), HEALTH_CHECK_INTERVAL_MS);
+        } catch (e) {
+            this.console.error(`Failed to setup MJPEG streams for ${this.name}`, (e as Error).message);
+        }
+    }
+
+    private async teardownStreams() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+        for (const [, producer] of this.producers) {
+            producer.stop();
+        }
+        this.producers.clear();
+        this.producerStartedAt.clear();
+        this.frameHubs.clear();
+        this.tokenToName.clear();
+    }
+
+    async release() {
+        if (this.killed) return;
+        this.killed = true;
+        this.console.log(`Releasing MJPEG mixin for ${this.name}`);
+        await this.teardownStreams();
+        super.release();
+    }
+}

package/src/frameHub.ts

@@ -0,0 +1,72 @@
+const BOUNDARY = 'mjpegboundary';
+
+/**
+ * Lightweight frame distribution hub for a single stream.
+ * Producers push JPEG frames, consumers subscribe via AsyncGenerator.
+ * Supports lifecycle callbacks for lazy start/stop of producers.
+ */
+export class FrameHub {
+    private listeners: Set<(frame: Buffer) => void> = new Set();
+
+    /** Called when subscriber count goes from 0 to 1. Awaited before streaming starts. */
+    onFirstSubscriber: (() => Promise<void> | void) | null = null;
+    /** Called when subscriber count goes from 1 to 0 */
+    onLastUnsubscribe: (() => void) | null = null;
+
+    push(frame: Buffer) {
+        for (const listener of this.listeners) {
+            listener(frame);
+        }
+    }
+
+    get subscriberCount(): number {
+        return this.listeners.size;
+    }
+
+    /**
+     * Create an AsyncGenerator that yields MJPEG multipart chunks.
+     * If this is the first subscriber, onFirstSubscriber is awaited before streaming.
+     */
+    async *subscribe(): AsyncGenerator<Buffer, void> {
+        const queue: Buffer[] = [];
+        let resolve: (() => void) | null = null;
+
+        const listener = (frame: Buffer) => {
+            const header = `\r\n--${BOUNDARY}\r\nContent-Type: image/jpeg\r\nContent-Length: ${frame.length}\r\n\r\n`;
+            const chunk = Buffer.concat([Buffer.from(header), frame]);
+            queue.push(chunk);
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        };
+
+        const wasEmpty = this.listeners.size === 0;
+        this.listeners.add(listener);
+
+        // Start producer if this is the first subscriber — await it so FFmpeg has time to start
+        if (wasEmpty && this.onFirstSubscriber) {
+            await this.onFirstSubscriber();
+        }
+
+        try {
+            while (true) {
+                if (queue.length === 0) {
+                    await new Promise<void>((r) => {
+                        resolve = r;
+                    });
+                }
+                while (queue.length > 0) {
+                    yield queue.shift()!;
+                }
+            }
+        } finally {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0 && this.onLastUnsubscribe) {
+                this.onLastUnsubscribe();
+            }
+        }
+    }
+}
+
+export const MJPEG_BOUNDARY = BOUNDARY;

package/src/main.ts

@@ -0,0 +1,146 @@
+import sdk, {
+    HttpRequest,
+    HttpRequestHandler,
+    HttpResponse,
+    MixinProvider,
+    ScryptedDeviceBase,
+    ScryptedDeviceType,
+    ScryptedInterface,
+    Setting,
+    Settings,
+    SettingValue,
+    WritableDeviceState,
+} from '@scrypted/sdk';
+import { StorageSettings } from '@scrypted/sdk/storage-settings';
+import { MjpegRebroadcastCameraMixin } from './cameraMixin';
+import { MJPEG_BOUNDARY } from './frameHub';
+
+const { endpointManager } = sdk;
+
+export default class MjpegRebroadcastPlugin
+    extends ScryptedDeviceBase
+    implements Settings, MixinProvider, HttpRequestHandler
+{
+    currentMixinsMap: Record<string, MjpegRebroadcastCameraMixin> = {};
+    private endpointUrlCache: string | null = null;
+
+    storageSettings = new StorageSettings(this, {});
+
+    constructor(nativeId: string) {
+        super(nativeId);
+        this.console.log('MJPEG Rebroadcast plugin loaded');
+    }
+
+    async getEndpointUrl(): Promise<string> {
+        if (this.endpointUrlCache) return this.endpointUrlCache;
+
+        let url = await endpointManager.getLocalEndpoint(undefined, {
+            public: true,
+            insecure: true,
+        });
+        url = url.replace(/\/+$/, '');
+        this.endpointUrlCache = url;
+        return url;
+    }
+
+    async getSettings(): Promise<Setting[]> {
+        return this.storageSettings.getSettings();
+    }
+
+    async putSetting(key: string, value: SettingValue): Promise<void> {
+        await this.storageSettings.putSetting(key, value);
+    }
+
+    async canMixin(type: ScryptedDeviceType, interfaces: string[]): Promise<string[]> {
+        if (
+            (type === ScryptedDeviceType.Camera || type === ScryptedDeviceType.Doorbell) &&
+            (interfaces.includes(ScryptedInterface.VideoCamera) || interfaces.includes(ScryptedInterface.Camera))
+        ) {
+            return [ScryptedInterface.Settings];
+        }
+        return [];
+    }
+
+    async getMixin(
+        mixinDevice: any,
+        mixinDeviceInterfaces: ScryptedInterface[],
+        mixinDeviceState: WritableDeviceState,
+    ): Promise<any> {
+        // Mixin self-registers in its constructor via this.plugin.currentMixinsMap
+        const mixin = new MjpegRebroadcastCameraMixin(
+            {
+                mixinDevice,
+                mixinDeviceInterfaces,
+                mixinDeviceState,
+                mixinProviderNativeId: this.nativeId,
+                group: 'MJPEG Rebroadcast',
+                groupKey: 'mjpegRebroadcast',
+            },
+            this,
+        );
+
+        return mixin;
+    }
+
+    async releaseMixin(id: string, mixinDevice: any): Promise<void> {
+        // Do NOT delete from currentMixinsMap here — Scrypted calls releaseMixin
+        // for the OLD mixin AFTER getMixin has already stored the NEW one.
+        // The new mixin constructor overwrites the map entry.
+        try {
+            await mixinDevice.release();
+        } catch (e) {
+            // this.console.warn(`Error releasing mixin ${id}: ${(e as Error).message}`);
+        }
+    }
+
+    async onRequest(request: HttpRequest, response: HttpResponse): Promise<void> {
+        const requestUrl = request.url || '';
+
+        // Extract the token: everything after /public/
+        const publicIdx = requestUrl.indexOf('/public/');
+        const token = publicIdx !== -1 ? requestUrl.slice(publicIdx + '/public/'.length) : '';
+
+        if (!token) {
+            // Global status
+            const streams: Record<string, { deviceName: string; streamName: string; subscribers: number }> = {};
+            for (const mixin of Object.values(this.currentMixinsMap)) {
+                if (mixin.killed) continue;
+                for (const [tok] of mixin.frameHubs) {
+                    streams[tok] = {
+                        deviceName: mixin.name,
+                        streamName: mixin.tokenToName.get(tok) ?? tok,
+                        subscribers: mixin.frameHubs.get(tok)?.subscriberCount ?? 0,
+                    };
+                }
+            }
+
+            response.send(JSON.stringify({ streams }, null, 2), {
+                code: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return;
+        }
+
+        // Find the hub by token across all active mixins
+        for (const mixin of Object.values(this.currentMixinsMap)) {
+            if (mixin.killed) continue;
+            const hub = mixin.frameHubs.get(token);
+            if (hub) {
+                const generator = hub.subscribe();
+                response.sendStream(generator, {
+                    code: 200,
+                    headers: {
+                        'Content-Type': `multipart/x-mixed-replace; boundary=${MJPEG_BOUNDARY}`,
+                        'Cache-Control': 'no-cache, no-store, must-revalidate',
+                        'Pragma': 'no-cache',
+                        'Expires': '0',
+                        'Connection': 'keep-alive',
+                    },
+                });
+                return;
+            }
+        }
+
+        response.send('Not found', { code: 404 });
+    }
+}

package/src/mjpegProducer.ts

@@ -0,0 +1,172 @@
+import sdk, { Camera, Settings } from '@scrypted/sdk';
+
+const { systemManager, mediaManager } = sdk;
+const { spawn } = require('child_process');
+
+export class MjpegProducer {
+    private console: Console;
+    private snapshotInterval: NodeJS.Timeout | null = null;
+    private ffmpegProcess: any = null;
+    private running = false;
+    debugLog: (message: string, ...args: any[]) => void = () => {};
+    onFrame: (frame: Buffer) => void = () => {};
+
+    constructor(console: Console) {
+        this.console = console;
+    }
+
+    async startSnapshotPolling(
+        deviceId: string,
+        fps: number = 2,
+    ): Promise<void> {
+        this.stop();
+        this.running = true;
+
+        const device = systemManager.getDeviceById(deviceId) as unknown as Camera;
+        if (!device?.takePicture) {
+            throw new Error(`Device ${deviceId} does not support Camera (snapshot) interface`);
+        }
+
+        const intervalMs = Math.max(100, Math.round(1000 / fps));
+        this.debugLog(`Starting snapshot polling at ${fps} fps (${intervalMs}ms interval)`);
+
+        const captureFrame = async () => {
+            if (!this.running) return;
+
+            try {
+                const picture = await device.takePicture();
+                const buffer = await mediaManager.convertMediaObjectToBuffer(picture, 'image/jpeg');
+                this.onFrame(Buffer.from(buffer));
+            } catch (e) {
+                this.console.warn(`Snapshot capture failed: ${(e as Error).message}`);
+            }
+        };
+
+        await captureFrame();
+        this.snapshotInterval = setInterval(captureFrame, intervalMs);
+    }
+
+    async startRtspToMjpeg(
+        rtspUrl: string,
+        fps: number = 5,
+        quality: number = 80,
+        width?: number,
+    ): Promise<void> {
+        this.stop();
+        this.running = true;
+
+        this.debugLog(`Starting RTSP→MJPEG conversion: ${rtspUrl}`);
+        await this.startFfmpegMjpeg(rtspUrl, fps, quality, width);
+    }
+
+    private async startFfmpegMjpeg(
+        inputUrl: string,
+        fps: number,
+        quality: number,
+        width?: number,
+    ): Promise<void> {
+        const ffmpegPath = await this.getFfmpegPath();
+
+        const args: string[] = [
+            '-rtsp_transport', 'tcp',
+            '-i', inputUrl,
+            '-f', 'image2pipe',
+            '-vcodec', 'mjpeg',
+            '-r', fps.toString(),
+            '-q:v', Math.max(1, Math.min(31, Math.round(31 - (quality / 100) * 30))).toString(),
+        ];
+
+        if (width) {
+            args.push('-vf', `scale=${width}:-1`);
+        }
+
+        args.push('-');
+
+        this.debugLog(`FFmpeg command: ${ffmpegPath} ${args.join(' ')}`);
+
+        this.ffmpegProcess = spawn(ffmpegPath, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        let jpegBuffer = Buffer.alloc(0);
+
+        this.ffmpegProcess.stdout.on('data', (data: Buffer) => {
+            jpegBuffer = Buffer.concat([jpegBuffer, data]);
+
+            while (true) {
+                const startIdx = jpegBuffer.indexOf(Buffer.from([0xFF, 0xD8]));
+                if (startIdx === -1) {
+                    jpegBuffer = Buffer.alloc(0);
+                    break;
+                }
+
+                const endIdx = jpegBuffer.indexOf(Buffer.from([0xFF, 0xD9]), startIdx + 2);
+                if (endIdx === -1) break;
+
+                const frame = jpegBuffer.subarray(startIdx, endIdx + 2);
+                this.onFrame(Buffer.from(frame));
+
+                jpegBuffer = jpegBuffer.subarray(endIdx + 2);
+            }
+        });
+
+        this.ffmpegProcess.stderr.on('data', (data: Buffer) => {
+            const msg = data.toString().trim();
+            if (msg) {
+                this.debugLog(`FFmpeg: ${msg}`);
+            }
+        });
+
+        this.ffmpegProcess.on('close', (code: number) => {
+            this.console.log(`FFmpeg process exited with code ${code} (running=${this.running})`);
+            this.ffmpegProcess = null;
+
+            if (this.running && code !== 0) {
+                this.console.warn('FFmpeg exited unexpectedly, restarting in 5 seconds...');
+                setTimeout(() => {
+                    if (this.running) {
+                        this.startFfmpegMjpeg(inputUrl, fps, quality, width);
+                    }
+                }, 5000);
+            }
+        });
+
+        this.ffmpegProcess.on('error', (err: Error) => {
+            this.console.error('FFmpeg process error', err.message);
+        });
+    }
+
+    private async getFfmpegPath(): Promise<string> {
+        try {
+            const ffmpegDevice = systemManager.getDeviceByName('FFmpeg');
+            if (ffmpegDevice) {
+                const settings = await (ffmpegDevice as unknown as Settings).getSettings();
+                const pathSetting = settings.find(s => s.key === 'ffmpegPath');
+                if (pathSetting?.value) return pathSetting.value as string;
+            }
+        } catch { /* ignore */ }
+
+        return 'ffmpeg';
+    }
+
+    stop() {
+        this.running = false;
+
+        if (this.snapshotInterval) {
+            clearInterval(this.snapshotInterval);
+            this.snapshotInterval = null;
+        }
+
+        if (this.ffmpegProcess) {
+            this.console.log('Sending SIGTERM to FFmpeg process');
+            try {
+                this.ffmpegProcess.kill('SIGTERM');
+            } catch { /* ignore */ }
+            this.ffmpegProcess = null;
+        }
+    }
+
+    get isRunning(): boolean {
+        return this.running;
+    }
+}

package/src/types.ts

@@ -0,0 +1,4 @@
+export enum MjpegSourceEnum {
+    ScryptedSnapshot = 'Scrypted Snapshot (polling)',
+    ScryptedRtspFfmpeg = 'Scrypted RTSP via FFmpeg',
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+
+{
+    "compilerOptions": {
+        "module": "Node16",
+        "target": "ES2021",
+        "resolveJsonModule": true,
+        "moduleResolution": "Node16",
+        "esModuleInterop": true,
+        "sourceMap": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/webpack.nodejs.config.js

@@ -0,0 +1,144 @@
+const path = require('path');
+const webpack = require('webpack');
+const TerserPlugin = require("terser-webpack-plugin");
+const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
+const fs = require('fs');
+
+let out;
+const cwd = process.cwd();
+
+if (process.env.NODE_ENV == 'production') {
+    out = path.resolve(cwd, 'dist');
+}
+else {
+    out = path.resolve(cwd, 'out');
+}
+
+const isProduction = process.env.NODE_ENV == 'production';
+
+function ensureAlias(name) {
+    const sanitizedName = name.replace(/@/g, '').replace(/\//g, '').replace(/-/g, '');
+    const sanitizedPath = path.join(__dirname, 'polyfill', sanitizedName + '.js');
+    const contents = `const ${sanitizedName} = __non_webpack_require__('${name}'); module.exports = ${sanitizedName};`
+    try {
+        if (fs.readFileSync(sanitizedPath).toString() !== contents)
+            throw new Error();
+    }
+    catch (e) {
+        fs.writeFileSync(sanitizedPath, contents);
+    }
+    return sanitizedPath;
+}
+
+const plugins = [
+    new webpack.DefinePlugin({
+        'process.env.SSDP_COV': false,
+    }),
+    new webpack.optimize.LimitChunkCountPlugin({
+        maxChunks: 1,
+    }),
+];
+
+if (process.env.WEBPACK_ANALYZER) {
+    plugins.push(
+        new BundleAnalyzerPlugin({
+            generateStatsFile: true,
+        }),
+    );
+}
+
+const alias = {};
+const polyfills = [
+    'node-pty-prebuilt-multiarch',
+    '@scrypted/node-pty',
+    'node-forge',
+    'sharp',
+    'source-map-support/register',
+    'adm-zip',
+    "memfs",
+    "realfs",
+    "fakefs",
+    "mdns",
+    "typescript",
+];
+
+for (const p of polyfills) {
+    alias[p] = ensureAlias(p);
+}
+
+module.exports = {
+    mode: process.env.NODE_ENV || 'development',
+    output: {
+        devtoolModuleFilenameTemplate: function (info) {
+            return path.relative(out, info.absoluteResourcePath);
+        },
+
+        // export everything to a var "window" which will be an alias for "exports" in Scrypted
+        library: {
+            name: 'exports',
+            type: 'assign-properties',
+        },
+    },
+    module: {
+        rules: [
+            process.env.SCRYPTED_WEBPACK_BABEL ?
+                {
+                    test: /\.(ts|js)x?$/,
+                    exclude: /(core-js)/,
+                    use: {
+                        loader: 'babel-loader',
+                        options: {
+                            "presets": [
+                                "@babel/preset-typescript",
+                            ]
+                        }
+                    }
+                } :
+                {
+                    test: /\.([cm]?ts|tsx)$/,
+                    loader: "ts-loader",
+                },
+            {
+                test: /\.node$/,
+                loader: "node-loader",
+            },
+        ],
+    },
+
+    node: {
+        __dirname: true,
+    },
+    target: "node",
+
+    resolveLoader: {
+        modules: module.paths,
+
+    },
+    resolve: {
+        alias,
+        extensions: ['.tsx', '.ts', '.js']
+    },
+
+    stats: {
+        colors: true
+    },
+
+    plugins,
+
+    optimization: {
+        minimize: isProduction,
+        minimizer: [
+            new TerserPlugin(
+                {
+                    terserOptions: {
+                        compress: {
+                            typeofs: false,
+                        }
+                    }
+                },
+            ),
+        ],
+    },
+
+    devtool: process.env.WEBPACK_DEVTOOL || 'source-map',
+};