@scrypted/server 0.6.24 → 0.7.2

package/src/plugin/media.ts

@@ -1,4 +1,4 @@
-import { BufferConverter, DeviceManager, FFmpegInput, MediaManager, MediaObject, MediaObjectOptions, MediaStreamUrl, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
+import { BufferConverter, DeviceManager, FFmpegInput, MediaManager, MediaObject as MediaObjectInterface, MediaObjectOptions, MediaStreamUrl, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
 import axios from 'axios';
 import pathToFfmpeg from 'ffmpeg-static';
 import fs from 'fs';
@@ -9,8 +9,28 @@ import Graph from 'node-dijkstra';
 import os from 'os';
 import path from 'path';
 import MimeType from 'whatwg-mimetype';
+import { RpcPeer } from "../rpc";
 import { MediaObjectRemote } from "./plugin-api";
 
+class MediaObject implements MediaObjectRemote {
+    __proxy_props: any;
+
+    constructor(public mimeType: string, public data: any, options: MediaObjectOptions) {
+        this.__proxy_props = {}
+        options ||= {};
+        options.mimeType = mimeType;
+        for (const [key, value] of Object.entries(options)) {
+            if (RpcPeer.isTransportSafe(value))
+                this.__proxy_props[key] = value;
+            (this as any)[key] = value;
+        }
+    }
+
+    async getData(): Promise<Buffer | string> {
+        return Promise.resolve(this.data);
+    }
+}
+
 function typeMatches(target: string, candidate: string): boolean {
     // candidate will accept anything
     if (candidate === '*' || target === '*')
@@ -164,7 +184,7 @@ export abstract class MediaManagerBase implements MediaManager {
         this.extraConverters = [];
     }
 
-    async convertMediaObjectToJSON<T>(mediaObject: MediaObject, toMimeType: string): Promise<T> {
+    async convertMediaObjectToJSON<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T> {
         const buffer = await this.convertMediaObjectToBuffer(mediaObject, toMimeType);
         return JSON.parse(buffer.toString());
     }
@@ -231,7 +251,7 @@ export abstract class MediaManagerBase implements MediaManager {
         return converters;
     }
 
-    ensureMediaObjectRemote(mediaObject: string | MediaObject): MediaObjectRemote {
+    ensureMediaObjectRemote(mediaObject: string | MediaObjectInterface): MediaObjectRemote {
         if (typeof mediaObject === 'string') {
             const mime = mimeType.getType(mediaObject);
             return this.createMediaObjectRemote(mediaObject, mime);
@@ -239,36 +259,36 @@ export abstract class MediaManagerBase implements MediaManager {
         return mediaObject as MediaObjectRemote;
     }
 
-    async convertMediaObject<T>(mediaObject: MediaObject, toMimeType: string): Promise<T> {
+    async convertMediaObject<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T> {
         const converted = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         return converted.data;
     }
 
-    async convertMediaObjectToInsecureLocalUrl(mediaObject: string | MediaObject, toMimeType: string): Promise<string> {
+    async convertMediaObjectToInsecureLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string> {
         const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
         const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.InsecureLocalUrl);
         return url.data.toString();
     }
 
-    async convertMediaObjectToBuffer(mediaObject: MediaObject, toMimeType: string): Promise<Buffer> {
+    async convertMediaObjectToBuffer(mediaObject: MediaObjectInterface, toMimeType: string): Promise<Buffer> {
         const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         return intermediate.data as Buffer;
     }
-    async convertMediaObjectToLocalUrl(mediaObject: string | MediaObject, toMimeType: string): Promise<string> {
+    async convertMediaObjectToLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string> {
         const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
         const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.LocalUrl);
         return url.data.toString();
     }
-    async convertMediaObjectToUrl(mediaObject: string | MediaObject, toMimeType: string): Promise<string> {
+    async convertMediaObjectToUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string> {
         const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
         const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.Url);
         return url.data.toString();
     }
 
-    createMediaObjectRemote(data: any | Buffer | Promise<string | Buffer>, mimeType: string, options?: MediaObjectOptions): MediaObjectRemote {
+    createMediaObjectRemote<T extends MediaObjectOptions>(data: any | Buffer | Promise<string | Buffer>, mimeType: string, options?: T): MediaObjectRemote & T {
         if (typeof data === 'string')
             throw new Error('string is not a valid type. if you intended to send a url, use createMediaObjectFromUrl.');
         if (!mimeType)
@@ -280,26 +300,19 @@ export abstract class MediaManagerBase implements MediaManager {
             data = Buffer.from(JSON.stringify(data));
 
         const sourceId = typeof options?.sourceId === 'string' ? options?.sourceId : this.getPluginDeviceId();
-        class MediaObjectImpl implements MediaObjectRemote {
-            __proxy_props = {
-                mimeType,
-                sourceId,
-            }
-
-            mimeType = mimeType;
-            sourceId = sourceId;
-            async getData(): Promise<Buffer | string> {
-                return Promise.resolve(data);
-            }
+        if (sourceId) {
+            options ||= {} as T;
+            options.sourceId = sourceId;
         }
-        return new MediaObjectImpl();
+
+        return new MediaObject(mimeType, data, options) as MediaObject & T;
     }
 
-    async createFFmpegMediaObject(ffMpegInput: FFmpegInput, options?: MediaObjectOptions): Promise<MediaObject> {
+    async createFFmpegMediaObject(ffMpegInput: FFmpegInput, options?: MediaObjectOptions): Promise<MediaObjectInterface> {
         return this.createMediaObjectRemote(Buffer.from(JSON.stringify(ffMpegInput)), ScryptedMimeTypes.FFmpegInput, options);
     }
 
-    async createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObject> {
+    async createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObjectInterface> {
         const url = new URL(data);
         const scheme = url.protocol.slice(0, -1);
         const mimeType = ScryptedMimeTypes.SchemePrefix + scheme;
@@ -320,7 +333,7 @@ export abstract class MediaManagerBase implements MediaManager {
         return new MediaObjectImpl();
     }
 
-    async createMediaObject(data: any, mimeType: string, options?: MediaObjectOptions): Promise<MediaObject> {
+    async createMediaObject<T extends MediaObjectOptions>(data: any, mimeType: string, options?: T): Promise<MediaObjectInterface & T> {
         return this.createMediaObjectRemote(data, mimeType, options);
     }
 
@@ -423,7 +436,7 @@ export abstract class MediaManagerBase implements MediaManager {
             }
 
             if (converter.toMimeType === ScryptedMimeTypes.MediaObject) {
-                const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId }) as MediaObject;
+                const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId }) as MediaObjectInterface;
                 const found = await this.convertMediaObject(mo, toMimeType);
                 return {
                     data: found,
@@ -445,16 +458,6 @@ export abstract class MediaManagerBase implements MediaManager {
 export class MediaManagerImpl extends MediaManagerBase {
     constructor(public systemManager: SystemManager, public deviceManager: DeviceManager) {
         super();
-
-        this.builtinConverters.push({
-            id: getBuiltinId(this.builtinConverters.length),
-            name: 'ScryptedDeviceId to ScryptedDevice Converter',
-            fromMimeType: ScryptedMimeTypes.ScryptedDeviceId,
-            toMimeType: ScryptedMimeTypes.ScryptedDevice,
-            convert: async (data, fromMimeType, toMimeType) => {
-                return this.getDeviceById(data.toString());
-            }
-        });
     }
 
     getSystemState(): { [id: string]: { [property: string]: SystemDeviceState; }; } {

package/src/plugin/plugin-api.ts

@@ -168,10 +168,13 @@ export interface PluginRemoteLoadZipOptions {
      */
     unzippedPath?: string;
     fork?: boolean;
+
+    clusterId: string;
+    clusterSecret: string;
 }
 
 export interface PluginRemote {
-    loadZip(packageJson: any, zipData: Buffer | string, options?: PluginRemoteLoadZipOptions): Promise<any>;
+    loadZip(packageJson: any, zipData: Buffer | string, options: PluginRemoteLoadZipOptions): Promise<any>;
     setSystemState(state: { [id: string]: { [property: string]: SystemDeviceState } }): Promise<void>;
     setNativeId(nativeId: ScryptedNativeId, id: string, storage: { [key: string]: any }): Promise<void>;
     updateDeviceState(id: string, state: { [property: string]: SystemDeviceState }): Promise<void>;

package/src/plugin/plugin-console.ts

@@ -1,10 +1,9 @@
-import { ScryptedNativeId } from '@scrypted/types'
-import { listenZero } from '../listen-zero';
-import { Server } from 'net';
-import { once } from 'events';
-import net from 'net'
-import { Readable, PassThrough } from 'stream';
+import { DeviceManager, ScryptedNativeId, SystemManager } from '@scrypted/types';
 import { Console } from 'console';
+import { once } from 'events';
+import net, { Server } from 'net';
+import { PassThrough, Readable } from 'stream';
+import { listenZero } from '../listen-zero';
 
 export interface ConsoleServer {
     pluginConsole: Console;
@@ -20,6 +19,155 @@ export interface StdPassThroughs {
     buffers: Buffer[];
 }
 
+export function getConsole(hook: (stdout: PassThrough, stderr: PassThrough) => Promise<void>,
+    also?: Console, alsoPrefix?: string)  {
+
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+
+    hook(stdout, stderr);
+
+    const ret = new Console(stdout, stderr);
+
+    const methods = [
+        'log', 'warn',
+        'dir', 'timeLog',
+        'trace', 'assert',
+        'clear', 'count',
+        'countReset', 'group',
+        'groupEnd', 'table',
+        'debug', 'info',
+        'dirxml', 'error',
+        'groupCollapsed',
+    ];
+
+    const printers = ['log', 'info', 'debug', 'trace', 'warn', 'error'];
+    for (const m of methods) {
+        const old = (ret as any)[m].bind(ret);
+        (ret as any)[m] = (...args: any[]) => {
+            // prefer the mixin version for local/remote console dump.
+            if (also && alsoPrefix && printers.includes(m)) {
+                (also as any)[m](alsoPrefix, ...args);
+            }
+            else {
+                (console as any)[m](...args);
+            }
+            // call through to old method to ensure it gets written
+            // to log buffer.
+            old(...args);
+        }
+    }
+
+    return ret;
+}
+
+export function prepareConsoles(getConsoleName: () => string, systemManager: () => SystemManager, deviceManager: () => DeviceManager, getPlugins: () => Promise<any>) {
+    const deviceConsoles = new Map<string, Console>();
+    function getDeviceConsole (nativeId?: ScryptedNativeId) {
+        // the the plugin console is simply the default console
+        // and gets read from stderr/stdout.
+        if (!nativeId)
+            return console;
+
+        let ret = deviceConsoles.get(nativeId);
+        if (ret)
+            return ret;
+
+        ret = getConsole(async (stdout, stderr) => {
+            const connect = async () => {
+                const plugins = await getPlugins();
+                const port = await plugins.getRemoteServicePort(getConsoleName(), 'console-writer');
+                const socket = net.connect(port);
+                socket.write(nativeId + '\n');
+                const writer = (data: Buffer) => {
+                    socket.write(data);
+                };
+                stdout.on('data', writer);
+                stderr.on('data', writer);
+                socket.on('error', () => {
+                    stdout.removeAllListeners();
+                    stderr.removeAllListeners();
+                    stdout.pause();
+                    stderr.pause();
+                    setTimeout(connect, 10000);
+                });
+            };
+            connect();
+        }, undefined, undefined);
+
+        deviceConsoles.set(nativeId, ret);
+        return ret;
+    }
+
+    const mixinConsoles = new Map<string, Map<string, Console>>();
+
+    function getMixinConsole(mixinId: string, nativeId: ScryptedNativeId) {
+        let nativeIdConsoles = mixinConsoles.get(nativeId);
+        if (!nativeIdConsoles) {
+            nativeIdConsoles = new Map();
+            mixinConsoles.set(nativeId, nativeIdConsoles);
+        }
+
+        let ret = nativeIdConsoles.get(mixinId);
+        if (ret)
+            return ret;
+
+        ret = getConsole(async (stdout, stderr) => {
+            if (!mixinId) {
+                return;
+            }
+            const reconnect = () => {
+                stdout.removeAllListeners();
+                stderr.removeAllListeners();
+                stdout.pause();
+                stderr.pause();
+                setTimeout(tryConnect, 10000);
+            };
+
+            const connect = async () => {
+                const ds = deviceManager().getDeviceState(nativeId);
+                if (!ds) {
+                    // deleted?
+                    return;
+                }
+
+                const plugins = await getPlugins();
+                const { pluginId, nativeId: mixinNativeId } = await plugins.getDeviceInfo(mixinId);
+                const port = await plugins.getRemoteServicePort(pluginId, 'console-writer');
+                const socket = net.connect(port);
+                socket.write(mixinNativeId + '\n');
+                const writer = (data: Buffer) => {
+                    let str = data.toString().trim();
+                    str = str.replaceAll('\n', `\n[${ds.name}]: `);
+                    str = `[${ds.name}]: ` + str + '\n';
+                    socket.write(str);
+                };
+                stdout.on('data', writer);
+                stderr.on('data', writer);
+                socket.on('close', reconnect);
+            };
+
+            const tryConnect = async () => {
+                try {
+                    await connect();
+                }
+                catch (e) {
+                    reconnect();
+                }
+            }
+            tryConnect();
+        }, getDeviceConsole(nativeId), `[${systemManager().getDeviceById(mixinId)?.name}]`);
+
+        nativeIdConsoles.set(mixinId, ret);
+        return ret;
+    }
+    
+    return {
+        getDeviceConsole,
+        getMixinConsole,
+    }
+}
+
 export async function createConsoleServer(remoteStdout: Readable, remoteStderr: Readable, header: string) {
     const outputs = new Map<string, StdPassThroughs>();
 

package/src/plugin/plugin-device.ts

@@ -352,6 +352,9 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
         this.scrypted.stateManager.setPluginDeviceState(device, ScryptedInterfaceProperty.type, type);
         this.scrypted.stateManager.updateDescriptor(device);
     }
+    async setMixins(mixins: string[]): Promise<void> {
+
+    }
 
     async probe(): Promise<boolean> {
         try {

package/src/plugin/plugin-host.ts

@@ -41,6 +41,9 @@ export class PluginHost {
     scrypted: ScryptedRuntime;
     remote: PluginRemote;
     io: IOServer = new io.Server({
+        // object detection drag drop 4k can be massive.
+        // streaming support somehow?
+        maxHttpBufferSize: 20000000,
         pingTimeout: 120000,
         perMessageDeflate: true,
         cors: (req, callback) => {
@@ -242,6 +245,8 @@ export class PluginHost {
             try {
                 const isPython = runtime === 'python';
                 const loadZipOptions: PluginRemoteLoadZipOptions = {
+                    clusterId: scrypted.clusterId,
+                    clusterSecret: scrypted.clusterSecret,
                     // if debugging, use a normalized path for sourcemap resolution, otherwise
                     // prefix with module path.
                     filename: isPython

package/src/plugin/plugin-remote-stats.ts

@@ -0,0 +1,36 @@
+import { NodeThreadWorker } from "./runtime/node-thread-worker";
+
+export interface PluginStats {
+    type: 'stats',
+    cpu: NodeJS.CpuUsage;
+    memoryUsage: NodeJS.MemoryUsage;
+}
+
+export function startStatsUpdater(allMemoryStats: Map<NodeThreadWorker, NodeJS.MemoryUsage>, updateStats: (stats: PluginStats) => void) {
+    setInterval(() => {
+        const cpuUsage = process.cpuUsage();
+        allMemoryStats.set(undefined, process.memoryUsage());
+
+        const memoryUsage: NodeJS.MemoryUsage = {
+            rss: 0,
+            heapTotal: 0,
+            heapUsed: 0,
+            external: 0,
+            arrayBuffers: 0,
+        }
+
+        for (const mu of allMemoryStats.values()) {
+            memoryUsage.rss += mu.rss;
+            memoryUsage.heapTotal += mu.heapTotal;
+            memoryUsage.heapUsed += mu.heapUsed;
+            memoryUsage.external += mu.external;
+            memoryUsage.arrayBuffers += mu.arrayBuffers;
+        }
+
+        updateStats({
+            type: 'stats',
+            cpu: cpuUsage,
+            memoryUsage,
+        });
+    }, 10000);
+}