@scrypted/server 0.0.132 → 0.0.137

package/src/plugin/media.ts

@@ -1,5 +1,4 @@
-import { ScryptedInterfaceProperty, SystemDeviceState, MediaStreamUrl, VideoCamera, Camera, BufferConverter, FFMpegInput, MediaManager, MediaObject, ScryptedDevice, ScryptedInterface, ScryptedMimeTypes, SystemManager, SCRYPTED_MEDIA_SCHEME } from "@scrypted/sdk/types";
-import { convert, ensureBuffer } from "../convert";
+import { ScryptedInterfaceProperty, SystemDeviceState, MediaStreamUrl, VideoCamera, Camera, BufferConverter, FFMpegInput, MediaManager, MediaObject, ScryptedDevice, ScryptedInterface, ScryptedMimeTypes, SystemManager } from "@scrypted/types";
 import { MediaObjectRemote } from "./plugin-api";
 import mimeType from 'mime'
 import child_process from 'child_process';
@@ -9,106 +8,132 @@ import tmp from 'tmp';
 import os from 'os';
 import { getInstalledFfmpeg } from '@scrypted/ffmpeg'
 import { ffmpegLogInitialOutput } from "../media-helpers";
+import Graph from 'node-dijkstra';
+import MimeType from 'whatwg-mimetype';
+import axios from 'axios';
+import https from 'https';
+
+function typeMatches(target: string, candidate: string): boolean {
+    // candidate will accept anything
+    if (candidate === '*')
+        return true;
+    return target === candidate;
+}
 
-function addBuiltins(console: Console, mediaManager: MediaManager) {
-    mediaManager.builtinConverters.push({
-        fromMimeType: `${ScryptedMimeTypes.Url};${ScryptedMimeTypes.AcceptUrlParameter}=true`,
-        toMimeType: ScryptedMimeTypes.FFmpegInput,
-        async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
-            const url = data.toString();
-            const args: FFMpegInput = {
-                url,
-                inputArguments: [
-                    '-i',
-                    url,
-                ],
-            }
+function mimeMatches(target: MimeType, candidate: MimeType) {
+    return typeMatches(target.type, candidate.type) && typeMatches(target.subtype, candidate.subtype);
+}
 
-            return Buffer.from(JSON.stringify(args));
-        }
-    });
+const httpsAgent = new https.Agent({
+    rejectUnauthorized: false
+})
 
-    mediaManager.builtinConverters.push({
-        fromMimeType: ScryptedMimeTypes.FFmpegInput,
-        toMimeType: ScryptedMimeTypes.MediaStreamUrl,
-        async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
-            return data;
+export abstract class MediaManagerBase implements MediaManager {
+    builtinConverters: BufferConverter[] = [];
+
+    constructor(public console: Console) {
+        for (const h of ['http', 'https']) {
+            this.builtinConverters.push({
+                fromMimeType: ScryptedMimeTypes.SchemePrefix + h,
+                toMimeType: ScryptedMimeTypes.MediaObject,
+                convert: async (data, fromMimeType, toMimeType) => {
+                    const ab = await axios.get(data.toString(), {
+                        responseType: 'arraybuffer',
+                        httpsAgent,
+                    });
+                    const mimeType = ab.headers['content-type'] || toMimeType;
+                    const mo = this.createMediaObject(Buffer.from(ab.data), mimeType);
+                    return mo;
+                }
+            });
         }
-    });
-
-    mediaManager.builtinConverters.push({
-        fromMimeType: ScryptedMimeTypes.MediaStreamUrl,
-        toMimeType: ScryptedMimeTypes.FFmpegInput,
-        async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
-            const mediaUrl: MediaStreamUrl = JSON.parse(data.toString());
-
-            const inputArguments: string[] = [
-                '-i',
-                mediaUrl.url,
-            ];
-
-            if (mediaUrl.url.startsWith('rtsp://')) {
-                inputArguments.unshift(
-                    // should this be set here? configurable?
-                    // do we ever want udp?
-                    "-rtsp_transport",
-                    "tcp",
-                    // 10 seconds
-                    '-analyzeduration', '10000000',
-                    // 20mb
-                    '-probesize', '20000000',
-                    "-reorder_queue_size",
-                    "1024",
-                    "-max_delay",
-                    // 10 second delay
-                    "10000000",
-                )
-            }
 
-            const ret: FFMpegInput = Object.assign({
-                inputArguments,
-            }, mediaUrl);
+        this.builtinConverters.push({
+            fromMimeType: `${ScryptedMimeTypes.Url};${ScryptedMimeTypes.AcceptUrlParameter}=true`,
+            toMimeType: ScryptedMimeTypes.FFmpegInput,
+            async convert(data, fromMimeType): Promise<Buffer> {
+                const url = data.toString();
+                const args: FFMpegInput = {
+                    url,
+                    inputArguments: [
+                        '-i', url,
+                    ],
+                }
 
-            return Buffer.from(JSON.stringify(ret));
-        }
-    })
-
-    mediaManager.builtinConverters.push({
-        fromMimeType: ScryptedMimeTypes.FFmpegInput,
-        toMimeType: 'image/jpeg',
-        async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
-            const ffInput: FFMpegInput = JSON.parse(data.toString());
-
-            const args = [
-                '-hide_banner',
-            ];
-            args.push(...ffInput.inputArguments);
-
-            const tmpfile = tmp.fileSync();
-            args.push('-y', "-vframes", "1", '-f', 'image2', tmpfile.name);
-
-            const cp = child_process.spawn(await mediaManager.getFFmpegPath(), args);
-            ffmpegLogInitialOutput(console, cp);
-            cp.on('error', (code) => {
-                console.error('ffmpeg error code', code);
-            })
-            const to = setTimeout(() => {
-                console.log('ffmpeg stream to image convesion timed out.');
-                cp.kill('SIGKILL');
-            }, 10000);
-            await once(cp, 'exit');
-            clearTimeout(to);
-            const ret = fs.readFileSync(tmpfile.name);
-            return ret;
-        }
-    });
-}
+                return Buffer.from(JSON.stringify(args));
+            }
+        });
 
-export abstract class MediaManagerBase implements MediaManager {
-    builtinConverters: BufferConverter[] = [];
+        this.builtinConverters.push({
+            fromMimeType: ScryptedMimeTypes.FFmpegInput,
+            toMimeType: ScryptedMimeTypes.MediaStreamUrl,
+            async convert(data: Buffer, fromMimeType: string): Promise<Buffer> {
+                return data;
+            }
+        });
+
+        this.builtinConverters.push({
+            fromMimeType: ScryptedMimeTypes.MediaStreamUrl,
+            toMimeType: ScryptedMimeTypes.FFmpegInput,
+            async convert(data, fromMimeType: string): Promise<Buffer> {
+                const mediaUrl: MediaStreamUrl = JSON.parse(data.toString());
+
+                const inputArguments: string[] = [
+                    '-i', mediaUrl.url,
+                ];
+
+                if (mediaUrl.url.startsWith('rtsp://')) {
+                    inputArguments.unshift(
+                        "-rtsp_transport", "tcp",
+                        "-max_delay", "1000000",
+                    );
+                }
+
+                const ret: FFMpegInput = Object.assign({
+                    inputArguments,
+                }, mediaUrl);
+
+                return Buffer.from(JSON.stringify(ret));
+            }
+        });
 
-    constructor(public console: Console) {
-        addBuiltins(this.console, this);
+        this.builtinConverters.push({
+            fromMimeType: 'image/*',
+            toMimeType: 'image/*',
+            convert: async (data, fromMimeType: string): Promise<Buffer> => {
+                return data as Buffer;
+            }
+        });
+
+        this.builtinConverters.push({
+            fromMimeType: ScryptedMimeTypes.FFmpegInput,
+            toMimeType: 'image/jpeg',
+            convert: async (data, fromMimeType: string): Promise<Buffer> => {
+                const ffInput: FFMpegInput = JSON.parse(data.toString());
+
+                const args = [
+                    '-hide_banner',
+                ];
+                args.push(...ffInput.inputArguments);
+
+                const tmpfile = tmp.fileSync();
+                args.push('-y', "-vframes", "1", '-f', 'image2', tmpfile.name);
+
+                const cp = child_process.spawn(await this.getFFmpegPath(), args);
+                ffmpegLogInitialOutput(console, cp);
+                cp.on('error', (code) => {
+                    console.error('ffmpeg error code', code);
+                })
+                const to = setTimeout(() => {
+                    console.log('ffmpeg stream to image convesion timed out.');
+                    cp.kill('SIGKILL');
+                }, 10000);
+                await once(cp, 'exit');
+                clearTimeout(to);
+                const ret = fs.readFileSync(tmpfile.name);
+                return ret;
+            }
+        });
     }
 
     abstract getSystemState(): { [id: string]: { [property: string]: SystemDeviceState } };
@@ -153,26 +178,26 @@ export abstract class MediaManagerBase implements MediaManager {
     }
 
     async convertMediaObjectToInsecureLocalUrl(mediaObject: string | MediaObject, toMimeType: string): Promise<string> {
-        const intermediate = await convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObject(intermediate.data, intermediate.mimeType);
-        const url = await convert(this.getConverters(), converted, ScryptedMimeTypes.InsecureLocalUrl);
+        const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.InsecureLocalUrl);
         return url.data.toString();
     }
 
     async convertMediaObjectToBuffer(mediaObject: MediaObject, toMimeType: string): Promise<Buffer> {
-        const intermediate = await convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
-        return ensureBuffer(intermediate.data);
+        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> {
-        const intermediate = await convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObject(intermediate.data, intermediate.mimeType);
-        const url = await convert(this.getConverters(), converted, ScryptedMimeTypes.LocalUrl);
+        const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.LocalUrl);
         return url.data.toString();
     }
     async convertMediaObjectToUrl(mediaObject: string | MediaObject, toMimeType: string): Promise<string> {
-        const intermediate = await convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
         const converted = this.createMediaObject(intermediate.data, intermediate.mimeType);
-        const url = await convert(this.getConverters(), converted, ScryptedMimeTypes.Url);
+        const url = await this.convert(this.getConverters(), converted, ScryptedMimeTypes.Url);
         return url.data.toString();
     }
 
@@ -194,25 +219,116 @@ export abstract class MediaManagerBase implements MediaManager {
         return new MediaObjectImpl();
     }
 
-    async createMediaObjectFromUrl(data: string, mimeType?: string): Promise<MediaObject> {
-        if (!data.startsWith(SCRYPTED_MEDIA_SCHEME))
-            return this.createMediaObject(data, mimeType || ScryptedMimeTypes.Url);
+    async createMediaObjectFromUrl(data: string): Promise<MediaObject> {
+        const url = new URL(data);
+        const scheme = url.protocol.slice(0, -1);
+        const fromMimeType = ScryptedMimeTypes.SchemePrefix + scheme;
+        return this.createMediaObject(data, fromMimeType);
+    }
+
+    async convert(converters: BufferConverter[], mediaObject: MediaObjectRemote, toMimeType: string): Promise<{ data: Buffer | string, mimeType: string }> {
+        // console.log('converting', mediaObject.mimeType, toMimeType);
+        const mediaMime = new MimeType(mediaObject.mimeType);
+        const outputMime = new MimeType(toMimeType);
 
-        const url = new URL(data.toString());
-        const id = url.hostname;
-        const path = url.pathname.split('/')[1];
-        let mo: MediaObject;
-        if (path === ScryptedInterface.VideoCamera) {
-            mo = await this.getDeviceById<VideoCamera>(id).getVideoStream();
+        if (mimeMatches(mediaMime, outputMime)) {
+            return {
+                mimeType: outputMime.essence,
+                data: await mediaObject.getData(),
+            }
         }
-        else if (path === ScryptedInterface.Camera) {
-            mo = await this.getDeviceById<Camera>(id).takePicture() as any;
+
+        const converterIds = new Map<BufferConverter, string>();
+        const converterReverseids = new Map<string, BufferConverter>();
+        let id = 0;
+        for (const converter of converters) {
+            const cid = (id++).toString();
+            converterIds.set(converter, cid);
+            converterReverseids.set(cid, converter);
         }
-        else {
-            throw new Error('Unrecognized Scrypted Media interface.')
+
+        const nodes: any = {};
+        const mediaNode: any = {};
+        nodes['mediaObject'] = mediaNode;
+        nodes['output'] = {};
+        for (const converter of converters) {
+            try {
+                const inputMime = new MimeType(converter.fromMimeType);
+                const convertedMime = new MimeType(converter.toMimeType);
+                const targetId = converterIds.get(converter);
+                const node: any = nodes[targetId] = {};
+                for (const candidate of converters) {
+                    try {
+                        const candidateMime = new MimeType(candidate.fromMimeType);
+                        if (!mimeMatches(convertedMime, candidateMime))
+                            continue;
+                        const candidateId = converterIds.get(candidate);
+                        node[candidateId] = 1;
+                    }
+                    catch (e) {
+                        console.warn('skipping converter due to error', e)
+                    }
+                }
+
+                if (mimeMatches(mediaMime, inputMime)) {
+                    mediaNode[targetId] = 1;
+                }
+                if (mimeMatches(outputMime, convertedMime) || converter.toMimeType === ScryptedMimeTypes.MediaObject) {
+                    node['output'] = 1;
+                }
+            }
+            catch (e) {
+                console.warn('skipping converter due to error', e)
+            }
+        }
+
+        const graph = new Graph();
+        for (const id of Object.keys(nodes)) {
+            graph.addNode(id, nodes[id]);
+        }
+
+        const route = graph.path('mediaObject', 'output') as Array<string>;
+        if (!route || !route.length)
+            throw new Error('no converter found');
+        // pop off the mediaObject start node, no conversion necessary.
+        route.shift();
+        // also remove the output node.
+        route.splice(route.length - 1);
+        let value = await mediaObject.getData();
+        let valueMime = new MimeType(mediaObject.mimeType);
+        for (const node of route) {
+            const converter = converterReverseids.get(node);
+            const converterToMimeType = new MimeType(converter.toMimeType);
+            const converterFromMimeType = new MimeType(converter.fromMimeType);
+            const type = converterToMimeType.type === '*' ? valueMime.type : converterToMimeType.type;
+            const subtype = converterToMimeType.subtype === '*' ? valueMime.subtype : converterToMimeType.subtype;
+            const targetMimeType = `${type}/${subtype}`;
+
+            if (typeof value === 'string' && !converterFromMimeType.parameters.has(ScryptedMimeTypes.AcceptUrlParameter)) {
+                const url = new URL(value);
+                const scheme = url.protocol.slice(0, -1);
+                const fromMimeType = ScryptedMimeTypes.SchemePrefix + scheme;
+                for (const converter of this.getConverters()) {
+                    if (converter.fromMimeType !== fromMimeType || converter.toMimeType !== ScryptedMimeTypes.MediaObject)
+                        continue;
+
+                    const mo = await converter.convert(value, fromMimeType, toMimeType) as MediaObject;
+                    const found = await this.convertMediaObjectToBuffer(mo, toMimeType);
+                    return {
+                        data: found,
+                        mimeType: mo.mimeType,
+                    };
+                }
+                throw new Error(`no ${ScryptedInterface.BufferConverter} exists for scheme: ${scheme}`);
+            }
+            value = await converter.convert(value, valueMime.essence, targetMimeType) as string | Buffer;
+            valueMime = new MimeType(targetMimeType);
         }
 
-        return mo;
+        return {
+            data: value,
+            mimeType: valueMime.essence,
+        };
     }
 }
 

package/src/plugin/plugin-api.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaObject, SystemDeviceState, MediaManager, HttpRequest } from '@scrypted/sdk/types'
+import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaObject, SystemDeviceState, MediaManager, HttpRequest } from '@scrypted/types'
 
 export interface PluginLogger {
     log(level: string, message: string): Promise<void>;

package/src/plugin/plugin-console.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId } from '@scrypted/sdk/types'
+import { ScryptedNativeId } from '@scrypted/types'
 import { listenZero } from './listen-zero';
 import { Server } from 'net';
 import { once } from 'events';

package/src/plugin/plugin-device.ts

@@ -1,7 +1,7 @@
-import { DeviceProvider, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/sdk/types";
+import { DeviceProvider, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/types";
 import { ScryptedRuntime } from "../runtime";
 import { PluginDevice } from "../db-types";
-import { MixinProvider } from "@scrypted/sdk/types";
+import { MixinProvider } from "@scrypted/types";
 import { handleFunctionInvocations, PrimitiveProxyHandler } from "../rpc";
 import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";
@@ -402,6 +402,11 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
             }
         }
 
+        if (method === 'getPluginJson'
+            && getState(pluginDevice, ScryptedInterfaceProperty.providedInterfaces)?.includes(ScryptedInterface.ScryptedPlugin)) {
+            return this.scrypted.getPackageJson(pluginDevice.pluginId);
+        }
+
         if (!isValidInterfaceMethod(pluginDevice.state.interfaces.value, method))
             throw new PluginError(`device ${this.id} does not support method ${method}`);
 

package/src/plugin/plugin-host-api.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest } from '@scrypted/sdk/types'
+import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest } from '@scrypted/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
 import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';

package/src/plugin/plugin-host.ts

@@ -1,6 +1,6 @@
 import { RpcPeer } from '../rpc';
 import AdmZip from 'adm-zip';
-import { Device, EngineIOHandler } from '@scrypted/sdk/types'
+import { Device, EngineIOHandler } from '@scrypted/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
 import io, { Socket } from 'engine.io';
@@ -27,6 +27,8 @@ import rimraf from 'rimraf';
 
 export class PluginHost {
     static sharedWorker: child_process.ChildProcess;
+    static sharedWorkerImmediateRestart = false;
+
     worker: child_process.ChildProcess;
     peer: RpcPeer;
     pluginId: string;
@@ -51,6 +53,9 @@ export class PluginHost {
     kill() {
         this.killed = true;
         this.api.removeListeners();
+        // things might get a bit race prone, so clear out the shared worker before killing.
+        if (this.worker === PluginHost.sharedWorker)
+            PluginHost.sharedWorker = undefined;
         this.worker.kill('SIGKILL');
         this.io.close();
         for (const s of Object.values(this.ws)) {
@@ -254,7 +259,7 @@ export class PluginHost {
                 // stdin, stdout, stderr, peer in, peer out
                 stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
                 env: Object.assign({
-                    PYTHONPATH: path.join(process.cwd(), 'node_modules/@scrypted/sdk'),
+                    PYTHONPATH: path.join(process.cwd(), 'node_modules/@scrypted/types'),
                 }, process.env, env),
             });
 
@@ -293,17 +298,22 @@ export class PluginHost {
                 Object.keys(this.packageJson.optionalDependencies || {}).length === 0;
             if (useSharedWorker) {
                 if (!PluginHost.sharedWorker) {
-                    PluginHost.sharedWorker = child_process.fork(require.main.filename, ['child', '@scrypted/shared'], {
+                    const worker = child_process.fork(require.main.filename, ['child', '@scrypted/shared'], {
                         stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
                         env: Object.assign({}, process.env, env),
                         serialization: 'advanced',
                         execArgv,
                     });
+                    PluginHost.sharedWorker = worker;
                     PluginHost.sharedWorker.setMaxListeners(100);
-                    PluginHost.sharedWorker.on('close', () => PluginHost.sharedWorker = undefined);
-                    PluginHost.sharedWorker.on('error', () => PluginHost.sharedWorker = undefined);
-                    PluginHost.sharedWorker.on('exit', () => PluginHost.sharedWorker = undefined);
-                    PluginHost.sharedWorker.on('disconnect', () => PluginHost.sharedWorker = undefined);
+                    const clearSharedWorker = () => {
+                        if (worker === PluginHost.sharedWorker)
+                            PluginHost.sharedWorker = undefined;
+                    };
+                    PluginHost.sharedWorker.on('close', () => clearSharedWorker);
+                    PluginHost.sharedWorker.on('error', () => clearSharedWorker);
+                    PluginHost.sharedWorker.on('exit', () => clearSharedWorker);
+                    PluginHost.sharedWorker.on('disconnect', () => clearSharedWorker);
                 }
                 PluginHost.sharedWorker.send({
                     type: 'start',

package/src/plugin/plugin-http.ts

@@ -1,6 +1,6 @@
 import { Request, Response, Router } from 'express';
 import bodyParser from 'body-parser';
-import { HttpRequest } from '@scrypted/sdk/types';
+import { HttpRequest } from '@scrypted/types';
 import WebSocket, { Server as WebSocketServer } from "ws";
 import { ServerResponse } from 'http';
 

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

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, SystemDeviceState } from '@scrypted/sdk/types'
+import { ScryptedNativeId, SystemDeviceState } from '@scrypted/types'
 import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 
 /**

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

@@ -1,5 +1,5 @@
 import { RpcMessage, RpcPeer } from '../rpc';
-import { SystemManager, DeviceManager, ScryptedNativeId } from '@scrypted/sdk/types'
+import { SystemManager, DeviceManager, ScryptedNativeId } from '@scrypted/types'
 import { attachPluginRemote, PluginReader } from './plugin-remote';
 import { PluginAPI } from './plugin-api';
 import { MediaManagerImpl } from './media';

package/src/plugin/plugin-remote.ts

@@ -1,14 +1,14 @@
 import AdmZip from 'adm-zip';
 import { Volume } from 'memfs';
 import path from 'path';
-import { ScryptedNativeId, DeviceManager, Logger, Device, DeviceManifest, DeviceState, EndpointManager, SystemDeviceState, ScryptedStatic, SystemManager, MediaManager, ScryptedMimeTypes, ScryptedInterface, ScryptedInterfaceProperty, HttpRequest } from '@scrypted/sdk/types'
+import { ScryptedNativeId, DeviceManager, Logger, Device, DeviceManifest, DeviceState, EndpointManager, SystemDeviceState, ScryptedStatic, SystemManager, MediaManager, ScryptedMimeTypes, ScryptedInterface, ScryptedInterfaceProperty, HttpRequest } from '@scrypted/types'
 import { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { SystemManagerImpl } from './system';
 import { RpcPeer, RPCResultError, PROPERTY_PROXY_ONEWAY_METHODS, PROPERTY_JSON_DISABLE_SERIALIZATION } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
 import { createWebSocketClass, WebSocketConnectCallbacks, WebSocketMethods } from './plugin-remote-websocket';
 import fs from 'fs';
-const {link} = require('linkfs');
+const { link } = require('linkfs');
 
 class DeviceLogger implements Logger {
     nativeId: ScryptedNativeId;
@@ -530,10 +530,18 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                     peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
                     pluginConsole?.log('plugin successfully loaded');
                     await options?.onPluginReady?.(ret, params, exports.default);
-                    return exports.default;
+
+                    const defaultExport = exports.default;
+                    // support exporting a plugin class, plugin main function,
+                    // or a plugin instance
+                    if (defaultExport.toString().startsWith('class '))
+                        return new defaultExport();
+                    if (typeof defaultExport === 'function')
+                        return await defaultExport();
+                    return defaultExport;
                 }
                 catch (e) {
-                    pluginConsole?.error('plugin failed to load', e);
+                    pluginConsole?.error('plugin failed to start', e);
                     throw e;
                 }
             },

package/src/plugin/plugin-repl.ts

@@ -2,7 +2,7 @@ import { listenZero } from './listen-zero';
 import { Server } from 'net';
 import { once } from 'events';
 import repl from 'repl';
-import { ScryptedStatic } from '@scrypted/sdk';
+import { ScryptedStatic } from '@scrypted/types';
 
 export async function createREPLServer(scrypted: ScryptedStatic, params: any, plugin: any): Promise<number> {
     const { deviceManager, systemManager } = scrypted;

package/src/plugin/system.ts

@@ -1,4 +1,4 @@
-import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger } from "@scrypted/sdk/types";
+import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger } from "@scrypted/types";
 import { PluginAPI } from "./plugin-api";
 import { handleFunctionInvocations, PrimitiveProxyHandler, PROPERTY_PROXY_ONEWAY_METHODS } from '../rpc';
 import { EventRegistry } from "../event-registry";