@scrypted/server 0.1.13 → 0.1.16

package/python/plugin-remote.py

@@ -6,7 +6,6 @@ import gc
 import json
 import os
 import platform
-import resource
 import shutil
 import subprocess
 import threading
@@ -21,7 +20,6 @@ from os import sys
 from typing import Any, Optional, Set, Tuple
 
 import aiofiles
-import gi
 import scrypted_python.scrypted_sdk.types
 from scrypted_python.scrypted_sdk.types import (Device, DeviceManifest,
                                                 MediaManager,
@@ -31,12 +29,6 @@ from typing_extensions import TypedDict
 
 import rpc
 
-gi.require_version('Gst', '1.0')
-
-from gi.repository import GLib, Gst
-
-Gst.init(None)
-
 class SystemDeviceState(TypedDict):
     lastEventTime: int
     stateTime: int
@@ -227,9 +219,9 @@ class PluginRemote:
         if not os.path.exists(python_prefix):
             os.makedirs(python_prefix)
 
-        python = 'python%s' % str(
+        python_version = 'python%s' % str(
             sys.version_info[0])+"."+str(sys.version_info[1])
-        print('python:', python)
+        print('python version:', python_version)
 
         if 'requirements.txt' in zip.namelist():
             requirements = zip.open('requirements.txt').read()
@@ -254,7 +246,7 @@ class PluginRemote:
                 f.write(requirements)
                 f.close()
 
-                p = subprocess.Popen([python, '-m', 'pip', 'install', '-r', requirementstxt,
+                p = subprocess.Popen([sys.executable, '-m', 'pip', 'install', '-r', requirementstxt,
                                      '--prefix', python_prefix], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
                 while True:
                     line = p.stdout.readline()
@@ -275,8 +267,13 @@ class PluginRemote:
                 print(str_requirements)
 
         sys.path.insert(0, zipPath)
-        site_packages = os.path.join(
-            python_prefix, 'lib/%s/site-packages' % python)
+        if platform.system() != 'Windows':
+            site_packages = os.path.join(
+                python_prefix, 'lib', python_version, 'site-packages')
+        else:
+            site_packages = os.path.join(
+                python_prefix, 'Lib', 'site-packages')
+        print('site-packages: %s' % site_packages)
         sys.path.insert(0, site_packages)
         from scrypted_sdk import sdk_init  # type: ignore
         self.systemManager = SystemManager(self.api, self.systemState)
@@ -366,7 +363,11 @@ async def async_main(loop: AbstractEventLoop):
 
         def stats_runner():
             ptime = round(time.process_time() * 1000000)
-            heapTotal = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+            try:
+                import resource
+                heapTotal = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+            except:
+                heapTotal = 0
             stats = {
                 'type': 'stats',
                 'cpuUsage': {
@@ -399,8 +400,16 @@ def main():
 
 
 if __name__ == "__main__":
-    worker = threading.Thread(target=main)
-    worker.start()
-
-    loop = GLib.MainLoop()
-    loop.run()
+    try:
+        import gi
+        gi.require_version('Gst', '1.0')
+        from gi.repository import GLib, Gst
+        Gst.init(None)
+
+        worker = threading.Thread(target=main)
+        worker.start()
+
+        loop = GLib.MainLoop()
+        loop.run()
+    except:
+        main()

package/src/http-interfaces.ts

@@ -3,6 +3,7 @@ import { Response } from "express";
 import { RpcPeer } from "./rpc";
 import { join as pathJoin } from 'path';
 import fs from 'fs';
+import net from 'net';
 
 const mime = require('mime/lite');
 
@@ -11,6 +12,7 @@ export function createResponseInterface(res: Response, unzippedDir: string, file
         [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = [
             'send',
             'sendFile',
+            'sendSocket',
         ];
 
         send(body: string): void;
@@ -61,6 +63,17 @@ export function createResponseInterface(res: Response, unzippedDir: string, file
             }
             res.sendFile(filePath);
         }
+
+        sendSocket(socket: net.Socket, options: HttpResponseOptions) {
+            if (options?.code)
+                res.status(options.code);
+            if (options?.headers) {
+                for (const header of Object.keys(options.headers)) {
+                    res.setHeader(header, (options.headers as any)[header]);
+                }
+            }
+            socket.pipe(res);
+        }
     }
 
     return new HttpResponseImpl();

package/src/plugin/media.ts

@@ -1,8 +1,8 @@
-import pathToFfmpeg from 'ffmpeg-static';
 import { BufferConverter, BufferConvertorOptions, DeviceManager, FFmpegInput, MediaManager, MediaObject, MediaObjectOptions, MediaStreamUrl, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
 import axios from 'axios';
 import child_process from 'child_process';
 import { once } from 'events';
+import pathToFfmpeg from 'ffmpeg-static';
 import fs from 'fs';
 import https from 'https';
 import mimeType from 'mime';
@@ -10,9 +10,8 @@ import mkdirp from "mkdirp";
 import Graph from 'node-dijkstra';
 import os from 'os';
 import path from 'path';
-import rimraf from "rimraf";
-import tmp from 'tmp';
 import MimeType from 'whatwg-mimetype';
+import { safeKillFFmpeg } from '../media-helpers';
 import { MediaObjectRemote } from "./plugin-api";
 
 function typeMatches(target: string, candidate: string): boolean {
@@ -32,6 +31,7 @@ const httpsAgent = new https.Agent({
 
 export abstract class MediaManagerBase implements MediaManager {
     builtinConverters: BufferConverter[] = [];
+    extraConverters: BufferConverter[] = [];
 
     constructor() {
         for (const h of ['http', 'https']) {
@@ -125,40 +125,59 @@ export abstract class MediaManagerBase implements MediaManager {
             convert: async (data, fromMimeType: string, toMimeType: string, options?: BufferConvertorOptions): Promise<Buffer> => {
                 const console = this.getMixinConsole(options?.sourceId, undefined);
 
+                const mt = new MimeType(toMimeType);
+
                 const ffInput: FFmpegInput = JSON.parse(data.toString());
 
                 const args = [
                     '-hide_banner',
+                    '-y',
                 ];
                 args.push(...ffInput.inputArguments);
 
-                const tmpfile = tmp.fileSync();
-                try {
-                    args.push('-y', "-vframes", "1", '-f', 'image2', tmpfile.name);
-
-                    const cp = child_process.spawn(await this.getFFmpegPath(), args);
-                    console.log('converting ffmpeg input to image.');
-                    // 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);
-                    clearTimeout(to);
-                    const [exitCode] = await once(cp, 'exit');
-                    if (exitCode)
-                        throw new Error(`ffmpeg stream to image convesion failed with exit code: ${exitCode}`);
-                    return fs.readFileSync(tmpfile.name);
-                }
-                finally {
-                    rimraf.sync(tmpfile.name);
+                const width = parseInt(mt.parameters.get('width'));
+                const height = parseInt(mt.parameters.get('height'));
+
+                if (mt.parameters.get('width') || mt.parameters.get('height')) {
+                    args.push(
+                        '-vf', `scale=${width || -1}:${height || -1}`,
+                    );
                 }
+
+                args.push("-vframes", "1", '-f', 'image2', 'pipe:3');
+
+                const buffers: Buffer[] = [];
+
+                const cp = child_process.spawn(await this.getFFmpegPath(), args, {
+                    stdio: ['pipe', 'pipe', 'pipe', 'pipe'],
+                });
+                console.log('converting ffmpeg input to image.');
+                // ffmpegLogInitialOutput(console, cp);
+                cp.on('error', (code) => {
+                    console.error('ffmpeg error code', code);
+                });
+                cp.stdio[3].on('data', data => buffers.push(data));
+                const to = setTimeout(() => {
+                    console.log('ffmpeg stream to image convesion timed out.');
+                    safeKillFFmpeg(cp);
+                }, 10000);
+                const [exitCode] = await once(cp, 'exit');
+                clearTimeout(to);
+                if (exitCode)
+                    throw new Error(`ffmpeg stream to image convesion failed with exit code: ${exitCode}`);
+                return Buffer.concat(buffers);
             }
         });
     }
 
+    async addConverter(converter: BufferConverter): Promise<void> {
+        this.extraConverters.push(converter);
+    }
+
+    async clearConverters(): Promise<void> {
+        this.extraConverters = [];
+    }
+
     async convertMediaObjectToJSON<T>(mediaObject: MediaObject, toMimeType: string): Promise<T> {
         const buffer = await this.convertMediaObjectToBuffer(mediaObject, toMimeType);
         return JSON.parse(buffer.toString());
@@ -204,7 +223,14 @@ export abstract class MediaManagerBase implements MediaManager {
         const converters = Object.entries(this.getSystemState())
             .filter(([id, state]) => state[ScryptedInterfaceProperty.interfaces]?.value?.includes(ScryptedInterface.BufferConverter))
             .map(([id]) => this.getDeviceById<BufferConverter>(id));
+
+        // builtins should be after system converters. these should not be overriden by system,
+        // as it could cause system instability with misconfiguration.
         converters.push(...this.builtinConverters);
+
+        // extra converters are added last and do allow overriding builtins, as
+        // the instability would be confined to a single plugin.
+        converters.push(...this.extraConverters);
         return converters;
     }
 
@@ -352,14 +378,16 @@ export abstract class MediaManagerBase implements MediaManager {
 
                 // edge matches
                 if (mimeMatches(mediaMime, inputMime)) {
+                    const weight = parseFloat(inputMime.parameters.get('converter-weight'));
                     // catch all converters should be heavily weighted so as not to use them.
-                    mediaNode[targetId] = inputMime.essence === '*/*' ? 1000 : 1;
+                    mediaNode[targetId] = weight || (inputMime.essence === '*/*' ? 1000 : 1);
                 }
 
                 // target output matches
                 if (mimeMatches(outputMime, convertedMime) || converter.toMimeType === ScryptedMimeTypes.MediaObject) {
+                    const weight = parseFloat(inputMime.parameters.get('converter-weight'));
                     // catch all converters should be heavily weighted so as not to use them.
-                    node['output'] = converter.toMimeType === ScryptedMimeTypes.MediaObject ? 1000 : 1;
+                    node['output'] = weight || (convertedMime.essence === ScryptedMimeTypes.MediaObject ? 1000 : 1);
                 }
             }
             catch (e) {
@@ -382,13 +410,21 @@ export abstract class MediaManagerBase implements MediaManager {
         let value = await mediaObject.getData();
         let valueMime = new MimeType(mediaObject.mimeType);
 
-        for (const node of route) {
+        while (route.length) {
+            const node = route.shift();
             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}`;
+            let targetMimeType = `${type}/${subtype}`;
+            if (!route.length && outputMime.parameters.size) {
+                const withParameters = new MimeType(targetMimeType);
+                for (const k of outputMime.parameters.keys()) {
+                    withParameters.parameters.set(k, outputMime.parameters.get(k));
+                }
+                targetMimeType = outputMime.toString();
+            }
 
             if (converter.toMimeType === ScryptedMimeTypes.MediaObject) {
                 const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId }) as MediaObject;
@@ -436,16 +472,12 @@ export class MediaManagerImpl extends MediaManagerBase {
 
 export class MediaManagerHostImpl extends MediaManagerBase {
     constructor(public pluginDeviceId: string,
-        public systemState: { [id: string]: { [property: string]: SystemDeviceState } },
+        public getSystemState: () => { [id: string]: { [property: string]: SystemDeviceState } },
         public console: Console,
         public getDeviceById: (id: string) => any) {
         super();
     }
 
-    getSystemState(): { [id: string]: { [property: string]: SystemDeviceState; }; } {
-        return this.systemState;
-    }
-
     getPluginDeviceId(): string {
         return this.pluginDeviceId;
     }

package/src/plugin/plugin-api.ts

@@ -147,6 +147,7 @@ export interface PluginRemoteLoadZipOptions {
      * exist on the "remote", if it is not the same machine.
      */
     unzippedPath?: string;
+    fork?: boolean;
 }
 
 export interface PluginRemote {

package/src/plugin/plugin-host.ts

@@ -135,7 +135,7 @@ export class PluginHost {
         this.io.on('connection', async (socket) => {
             try {
                 try {
-                    if (socket.request.url.indexOf('/api') !== -1) {
+                    if (socket.request.url.indexOf('/engine.io/api') !== -1) {
                         if (socket.request.url.indexOf('/public') !== -1) {
                             socket.close();
                             return;
@@ -179,7 +179,7 @@ export class PluginHost {
 
         const { runtime } = this.packageJson.scrypted;
         const mediaManager = runtime === 'python'
-            ? new MediaManagerHostImpl(pluginDeviceId, scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
+            ? new MediaManagerHostImpl(pluginDeviceId, () => scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
             : undefined;
 
         this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager);
@@ -374,7 +374,8 @@ export class PluginHost {
         serializer.setupRpcPeer(rpcPeer);
 
         // wrap the host api with a connection specific api that can be torn down on disconnect
-        const api = new PluginAPIProxy(this.api, await this.peer.getParam('mediaManager'));
+        const createMediaManager = await this.peer.getParam('createMediaManager');
+        const api = new PluginAPIProxy(this.api, await createMediaManager());
         const kill = () => {
             serializer.onDisconnected();
             api.removeListeners();
@@ -389,7 +390,8 @@ export class PluginHost {
         const rpcPeer = createDuplexRpcPeer(`api/${this.pluginId}`, 'duplex', duplex, duplex);
 
         // wrap the host api with a connection specific api that can be torn down on disconnect
-        const api = new PluginAPIProxy(this.api, await this.peer.getParam('mediaManager'));
+        const createMediaManager = await this.peer.getParam('createMediaManager');
+        const api = new PluginAPIProxy(this.api, await createMediaManager());
         const kill = () => {
             api.removeListeners();
         };

package/src/plugin/plugin-http.ts

@@ -38,7 +38,7 @@ export abstract class PluginHttp<T> {
 
     abstract handleEngineIOEndpoint(req: Request, res: ServerResponse, endpointRequest: HttpRequest, pluginData: T): void;
     abstract handleRequestEndpoint(req: Request, res: Response, endpointRequest: HttpRequest, pluginData: T): void;
-    abstract getEndpointPluginData(endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T>;
+    abstract getEndpointPluginData(req: Request, endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T>;
     abstract handleWebSocket(endpoint: string, httpRequest: HttpRequest, ws: WebSocket, pluginData: T): Promise<void>;
 
     async endpointHandler(req: Request, res: Response, isPublicEndpoint: boolean, isEngineIOEndpoint: boolean,
@@ -75,7 +75,7 @@ export abstract class PluginHttp<T> {
             return;
         }
 
-        const pluginData = await this.getEndpointPluginData(endpoint, isUpgrade, isEngineIOEndpoint);
+        const pluginData = await this.getEndpointPluginData(req, endpoint, isUpgrade, isEngineIOEndpoint);
         if (!pluginData) {
             end(404, 'Not Found');
             return;

package/src/plugin/plugin-npm-dependencies.ts

@@ -6,6 +6,7 @@ import { once } from 'events';
 import process from 'process';
 import mkdirp from "mkdirp";
 import semver from 'semver';
+import os from 'os';
 
 export function getPluginNodePath(name: string) {
     const pluginVolume = ensurePluginVolume(name);
@@ -48,7 +49,10 @@ export async function installOptionalDependencies(console: Console, packageJson:
     mkdirp.sync(nodePrefix);
     fs.writeFileSync(packageJsonPath, JSON.stringify(reduced));
 
-    const cp = child_process.spawn('npm', ['--prefix', nodePrefix, 'install'], {
+    let npm = 'npm';
+    if (os.platform() === 'win32')
+        npm += '.cmd';
+    const cp = child_process.spawn(npm, ['--prefix', nodePrefix, 'install'], {
         cwd: nodePrefix,
         stdio: 'inherit',
     });

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

@@ -1,16 +1,22 @@
 import { DeviceManager, ScryptedNativeId, ScryptedStatic, SystemManager } from '@scrypted/types';
+import AdmZip from 'adm-zip';
 import { Console } from 'console';
+import fs from 'fs';
+import { Volume } from 'memfs';
 import net from 'net';
+import path from 'path';
 import { install as installSourceMapSupport } from 'source-map-support';
 import { PassThrough } from 'stream';
 import { RpcMessage, RpcPeer } from '../rpc';
 import { MediaManagerImpl } from './media';
-import { PluginAPI } from './plugin-api';
+import { PluginAPI, PluginRemoteLoadZipOptions } from './plugin-api';
 import { installOptionalDependencies } from './plugin-npm-dependencies';
-import { attachPluginRemote, PluginReader } from './plugin-remote';
+import { attachPluginRemote, PluginReader, setupPluginRemote } from './plugin-remote';
 import { createREPLServer } from './plugin-repl';
+import { NodeThreadWorker } from './runtime/node-thread-worker';
+const { link } = require('linkfs');
 
-export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void) => void) {
+export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void) {
     const peer = new RpcPeer('unknown', 'host', peerSend);
 
     let systemManager: SystemManager;
@@ -66,13 +72,18 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
         return pluginsPromise;
     }
 
+    const deviceConsoles = new Map<string, Console>();
     const getDeviceConsole = (nativeId?: ScryptedNativeId) => {
         // the the plugin console is simply the default console
         // and gets read from stderr/stdout.
         if (!nativeId)
             return console;
 
-        return getConsole(async (stdout, stderr) => {
+        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(peer.selfName, 'console-writer');
@@ -93,10 +104,25 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             };
             connect();
         }, undefined, undefined);
+
+        deviceConsoles.set(nativeId, ret);
+        return ret;
     }
 
+    const mixinConsoles = new Map<string, Map<string, Console>>();
+
     const getMixinConsole = (mixinId: string, nativeId: ScryptedNativeId) => {
-        return getConsole(async (stdout, stderr) => {
+        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;
             }
@@ -147,6 +173,9 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             }
             tryConnect();
         }, getDeviceConsole(nativeId), `[${systemManager.getDeviceById(mixinId)?.name}]`);
+
+        nativeIdConsoles.set(mixinId, ret);
+        return ret;
     }
 
     peer.getParam('updateStats').then((updateStats: (stats: any) => void) => {
@@ -183,10 +212,6 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             api = _api;
             peer.selfName = pluginId;
         },
-        onPluginReady: async (scrypted, params, plugin) => {
-            replPort = createREPLServer(scrypted, params, plugin);
-            postInstallSourceMapSupport(scrypted);
-        },
         getPluginConsole,
         getDeviceConsole,
         getMixinConsole,
@@ -198,7 +223,59 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             }
             throw new Error(`unknown service ${name}`);
         },
-        async onLoadZip(pluginReader: PluginReader, packageJson: any) {
+        async onLoadZip(scrypted: ScryptedStatic, params: any, packageJson: any, zipData: Buffer | string, zipOptions?: PluginRemoteLoadZipOptions) {
+            let volume: any;
+            let pluginReader: PluginReader;
+            if (zipOptions?.unzippedPath && fs.existsSync(zipOptions?.unzippedPath)) {
+                volume = link(fs, ['', path.join(zipOptions.unzippedPath, 'fs')]);
+                pluginReader = name => {
+                    const filename = path.join(zipOptions.unzippedPath, name);
+                    if (!fs.existsSync(filename))
+                        return;
+                    return fs.readFileSync(filename);
+                };
+            }
+            else {
+                const admZip = new AdmZip(zipData);
+                volume = new Volume();
+                for (const entry of admZip.getEntries()) {
+                    if (entry.isDirectory)
+                        continue;
+                    if (!entry.entryName.startsWith('fs/'))
+                        continue;
+                    const name = entry.entryName.substring('fs/'.length);
+                    volume.mkdirpSync(path.dirname(name));
+                    const data = entry.getData();
+                    volume.writeFileSync(name, data);
+                }
+
+                pluginReader = name => {
+                    const entry = admZip.getEntry(name);
+                    if (!entry)
+                        return;
+                    return entry.getData();
+                }
+            }
+            zipData = undefined;
+
+            const pluginConsole = getPluginConsole?.();
+            params.console = pluginConsole;
+            params.require = (name: string) => {
+                if (name === 'fakefs' || (name === 'fs' && !packageJson.scrypted.realfs)) {
+                    return volume;
+                }
+                if (name === 'realfs') {
+                    return require('fs');
+                }
+                const module = require(name);
+                return module;
+            };
+            const window: any = {};
+            const exports: any = window;
+            window.exports = exports;
+            params.window = window;
+            params.exports = exports;
+
             const entry = pluginReader('main.nodejs.js.map')
             const map = entry?.toString();
 
@@ -234,6 +311,57 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             };
 
             await installOptionalDependencies(getPluginConsole(), packageJson);
+
+            const main = pluginReader('main.nodejs.js');
+            pluginReader = undefined;
+            const script = main.toString();
+
+            scrypted.fork = async () => {
+                const ntw = new NodeThreadWorker(pluginId, {
+                    env: process.env,
+                    pluginDebug: undefined,
+                });
+                const threadPeer = new RpcPeer('main', 'thread', (message, reject) => ntw.send(message, reject));
+                threadPeer.params.updateStats = (stats: any) => {
+                    // todo: merge.
+                    // this.stats = stats;
+                }
+                ntw.setupRpcPeer(threadPeer);
+
+                const remote = await setupPluginRemote(threadPeer, api, pluginId, () => systemManager.getSystemState());
+                const forkOptions = Object.assign({}, zipOptions);
+                forkOptions.fork = true;
+                return remote.loadZip(packageJson, zipData, forkOptions)
+            }
+
+            try {
+                peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
+                pluginConsole?.log('plugin successfully loaded');
+
+                if (zipOptions?.fork) {
+                    const fork = exports.fork;
+                    const ret = await fork();
+                    ret[RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION] = true;
+                    return ret;
+                }
+
+                let pluginInstance = exports.default;
+                // support exporting a plugin class, plugin main function,
+                // or a plugin instance
+                if (pluginInstance.toString().startsWith('class '))
+                    pluginInstance = new pluginInstance();
+                if (typeof pluginInstance === 'function')
+                    pluginInstance = await pluginInstance();
+
+                replPort = createREPLServer(scrypted, params, pluginInstance);
+                postInstallSourceMapSupport(scrypted);
+
+                return pluginInstance;
+            }
+            catch (e) {
+                pluginConsole?.error('plugin failed to start', e);
+                throw e;
+            }
         }
     }).then(scrypted => {
         systemManager = scrypted.systemManager;