@scrypted/server 0.0.116 → 0.0.121

package/python/rpc.py

@@ -308,8 +308,8 @@ class RpcPeer:
 
                     result['result'] = self.serialize(value, False)
                 except Exception as e:
-                    print('failure', method, e)
                     tb = traceback.format_exc()
+                    print('failure', method, e, tb)
                     self.createErrorResult(
                         result, type(e).__name__, str(e), tb)
 
@@ -317,11 +317,12 @@ class RpcPeer:
                     self.send(result)
 
             elif messageType == 'result':
-                future = self.pendingResults.get(message['id'], None)
+                id = message['id']
+                future = self.pendingResults.get(id, None)
                 if not future:
                     raise RpcResultException(
-                        None, 'unknown result %s' % message['id'])
-                del message['id']
+                        None, 'unknown result %s' % id)
+                del self.pendingResults[id]
                 if hasattr(message, 'message') or hasattr(message, 'stack'):
                     e = RpcResultException(
                         None, message.get('message', None))

package/src/http-interfaces.ts

@@ -1,10 +1,17 @@
 import { HttpResponse, HttpResponseOptions } from "@scrypted/sdk/types";
 import { Response } from "express";
 import mime from "mime";
-import AdmZip from "adm-zip";
+import { PROPERTY_PROXY_ONEWAY_METHODS } from "./rpc";
+import { join as pathJoin } from 'path';
+import fs from 'fs';
 
-export function createResponseInterface(res: Response, zip: AdmZip): HttpResponse {
+export function createResponseInterface(res: Response, unzippedDir: string): HttpResponse {
     class HttpResponseImpl implements HttpResponse {
+        [PROPERTY_PROXY_ONEWAY_METHODS] = [
+            'send',
+            'sendFile',
+        ];
+
         send(body: string): void;
         send(body: string, options: HttpResponseOptions): void;
         send(body: Buffer): void;
@@ -35,13 +42,13 @@ export function createResponseInterface(res: Response, zip: AdmZip): HttpRespons
             if (!res.getHeader('Content-Type'))
                 res.contentType(mime.lookup(path));
 
-            const data = zip.getEntry(`fs/${path}`)?.getData();
-            if (!data) {
+            const filePath = pathJoin(unzippedDir, 'fs', path);
+            if (!fs.existsSync(filePath)) {
                 res.status(404);
                 res.end();
                 return;
             }
-            res.send(data);
+            res.sendFile(filePath);
         }
     }
 

package/src/level.ts

@@ -5,8 +5,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
-import { asyncFilter } from "./asynciterable-utils";
-
 export interface AbstractOptions {
     // wtf is this?
     readonly [k: string]: any;

package/src/plugin/media.ts

@@ -7,12 +7,12 @@ import { once } from 'events';
 import fs from 'fs';
 import tmp from 'tmp';
 import os from 'os';
-import pathToFfmpeg from 'ffmpeg-for-homebridge';
+import { getInstalledFfmpeg } from '@scrypted/ffmpeg'
 import { ffmpegLogInitialOutput } from "../media-helpers";
 
 function addBuiltins(console: Console, mediaManager: MediaManager) {
     mediaManager.builtinConverters.push({
-        fromMimeType: ScryptedMimeTypes.Url + ';' + ScryptedMimeTypes.AcceptUrlParameter,
+        fromMimeType: `${ScryptedMimeTypes.Url};${ScryptedMimeTypes.AcceptUrlParameter}=true`,
         toMimeType: ScryptedMimeTypes.FFmpegInput,
         async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
             const url = data.toString();
@@ -94,7 +94,7 @@ function addBuiltins(console: Console, mediaManager: MediaManager) {
             })
             const to = setTimeout(() => {
                 console.log('ffmpeg stream to image convesion timed out.');
-                cp.kill();
+                cp.kill('SIGKILL');
             }, 10000);
             await once(cp, 'exit');
             clearTimeout(to);
@@ -133,7 +133,7 @@ export abstract class MediaManagerBase implements MediaManager {
             return f;
 
         const defaultPath = os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
-        return pathToFfmpeg || defaultPath;
+        return getInstalledFfmpeg() || defaultPath;
     }
 
     getConverters(): BufferConverter[] {

package/src/plugin/plugin-api.ts

@@ -132,11 +132,19 @@ export class PluginAPIProxy extends PluginAPIManagedListeners implements PluginA
 }
 
 export interface PluginRemoteLoadZipOptions {
+    /**
+     * The filename to load the script as. Use for debugger source mapping.
+     */
     filename?: string;
+    /**
+     * The path that the zip is currently unzipped at on the server. May not
+     * exist on the "remote", if it is not the same machine.
+     */
+    unzippedPath?: string;
 }
 
 export interface PluginRemote {
-    loadZip(packageJson: any, zipData: Buffer, 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,5 +1,4 @@
 import { ScryptedNativeId } from '@scrypted/sdk/types'
-import { EventEmitter } from 'ws';
 import { listenZero } from './listen-zero';
 import { Server } from 'net';
 import { once } from 'events';

package/src/plugin/plugin-device.ts

@@ -8,6 +8,8 @@ import { getDisplayType } from "../infer-defaults";
 import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from "./descriptor";
 import { PluginError } from "./plugin-error";
 import { sleep } from "../sleep";
+import path from 'path';
+import fs from 'fs';
 
 interface MixinTable {
     mixinProviderId: string;
@@ -382,9 +384,14 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
             if (pluginDevice && !pluginDevice.nativeId) {
                 const plugin = this.scrypted.plugins[pluginDevice.pluginId];
                 if (!plugin.packageJson.scrypted.interfaces.includes(ScryptedInterface.Readme)) {
-                    const entry = plugin.zip.getEntry('README.md');
-                    if (entry) {
-                        return entry.getData().toString();
+                    const readmePath = path.join(plugin.unzippedPath, 'README.md');
+                    if (fs.existsSync(readmePath)) {
+                        try {
+                            return fs.readFileSync(readmePath).toString();
+                        }
+                        catch (e) {
+                            return "# Error loading Readme:\n\n" + e;
+                        }
                     }
                 }
             }

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

@@ -35,9 +35,9 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         this.scrypted.runPlugin(plugin);
     }, 15000);
 
-    constructor(public scrypted: ScryptedRuntime, plugin: Plugin, public pluginHost: PluginHost, public mediaManager: MediaManager) {
+    constructor(public scrypted: ScryptedRuntime, pluginId: string, public pluginHost: PluginHost, public mediaManager: MediaManager) {
         super();
-        this.pluginId = plugin._id;
+        this.pluginId = pluginId;
     }
 
     // do we care about mixin validation here?

package/src/plugin/plugin-host.ts

@@ -1,39 +1,38 @@
-import { RpcMessage, RpcPeer } from '../rpc';
+import { RpcPeer } from '../rpc';
 import AdmZip from 'adm-zip';
-import { SystemManager, DeviceManager, ScryptedNativeId, Device, EventListenerRegister, EngineIOHandler, ScryptedInterface, ScryptedInterfaceProperty } from '@scrypted/sdk/types'
+import { Device, EngineIOHandler } from '@scrypted/sdk/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
 import io, { Socket } from 'engine.io';
-import { attachPluginRemote, setupPluginRemote } from './plugin-remote';
-import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
+import { setupPluginRemote } from './plugin-remote';
+import { PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { Logger } from '../logger';
-import { MediaManagerHostImpl, MediaManagerImpl } from './media';
+import { MediaManagerHostImpl } from './media';
 import WebSocket from 'ws';
-import { PassThrough } from 'stream';
-import { Console } from 'console'
 import { sleep } from '../sleep';
 import { PluginHostAPI } from './plugin-host-api';
 import path from 'path';
-import { install as installSourceMapSupport } from 'source-map-support';
-import net from 'net'
 import child_process from 'child_process';
 import { PluginDebug } from './plugin-debug';
 import readline from 'readline';
 import { Readable, Writable } from 'stream';
-import { ensurePluginVolume } from './plugin-volume';
-import { getPluginNodePath, installOptionalDependencies } from './plugin-npm-dependencies';
+import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
+import { getPluginNodePath } from './plugin-npm-dependencies';
 import { ConsoleServer, createConsoleServer } from './plugin-console';
-import { createREPLServer } from './plugin-repl';
 import { LazyRemote } from './plugin-lazy-remote';
+import crypto from 'crypto';
+import fs from 'fs';
+import mkdirp from 'mkdirp';
+import rimraf from 'rimraf';
 
 export class PluginHost {
+    static sharedWorker: child_process.ChildProcess;
     worker: child_process.ChildProcess;
     peer: RpcPeer;
     pluginId: string;
     module: Promise<any>;
     scrypted: ScryptedRuntime;
     remote: PluginRemote;
-    zip: AdmZip;
     io = io(undefined, {
         pingTimeout: 120000,
     });
@@ -47,11 +46,12 @@ export class PluginHost {
     };
     killed = false;
     consoleServer: Promise<ConsoleServer>;
+    unzippedPath: string;
 
     kill() {
         this.killed = true;
         this.api.removeListeners();
-        this.worker.kill();
+        this.worker.kill('SIGKILL');
         this.io.close();
         for (const s of Object.values(this.ws)) {
             s.close();
@@ -86,15 +86,19 @@ export class PluginHost {
         this.pluginId = plugin._id;
         this.pluginName = plugin.packageJson?.name;
         this.packageJson = plugin.packageJson;
-        const logger = scrypted.getDeviceLogger(scrypted.findPluginDevice(plugin._id));
+        let zipBuffer = Buffer.from(plugin.zip, 'base64');
+        // allow garbage collection of the base 64 contents
+        plugin = undefined;
 
-        const volume = path.join(process.cwd(), 'volume');
-        const cwd = ensurePluginVolume(this.pluginId);
+        const logger = scrypted.getDeviceLogger(scrypted.findPluginDevice(this.pluginId));
+
+        const volume = getScryptedVolume();
+        const pluginVolume = ensurePluginVolume(this.pluginId);
 
         this.startPluginHost(logger, {
             NODE_PATH: path.join(getPluginNodePath(this.pluginId), 'node_modules'),
-            SCRYPTED_PLUGIN_VOLUME: cwd,
-        }, plugin.packageJson.scrypted.runtime);
+            SCRYPTED_PLUGIN_VOLUME: pluginVolume,
+        }, this.packageJson.scrypted.runtime);
 
         this.io.on('connection', async (socket) => {
             try {
@@ -138,10 +142,26 @@ export class PluginHost {
             ? new MediaManagerHostImpl(scrypted.stateManager.getSystemState(), id => scrypted.getDevice(id), console)
             : undefined;
 
-        this.api = new PluginHostAPI(scrypted, plugin, this, mediaManager);
-
-        const zipBuffer = Buffer.from(plugin.zip, 'base64');
-        this.zip = new AdmZip(zipBuffer);
+        this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager);
+
+        const zipDir = path.join(pluginVolume, 'zip');
+        const extractVersion = "1-";
+        const hash = extractVersion + crypto.createHash('md5').update(zipBuffer).digest().toString('hex');
+        const zipFilename = `${hash}.zip`;
+        const zipFile = path.join(zipDir, zipFilename);
+        this.unzippedPath = path.join(zipDir, 'unzipped')
+        {
+            const zipDirTmp = zipDir + '.tmp';
+            if (!fs.existsSync(zipFile)) {
+                rimraf.sync(zipDirTmp);
+                rimraf.sync(zipDir);
+                mkdirp.sync(zipDirTmp);
+                fs.writeFileSync(path.join(zipDirTmp, zipFilename), zipBuffer);
+                const admZip = new AdmZip(zipBuffer);
+                admZip.extractAllTo(path.join(zipDirTmp, 'unzipped'), true);
+                fs.renameSync(zipDirTmp, zipDir);
+            }
+        }
 
         logger.log('i', `loading ${this.pluginName}`);
         logger.log('i', 'pid ' + this.worker?.pid);
@@ -170,18 +190,25 @@ export class PluginHost {
 
             const fail = 'Plugin failed to load. Console for more information.';
             try {
+                const isPython = runtime === 'python';
                 const loadZipOptions: PluginRemoteLoadZipOptions = {
                     // if debugging, use a normalized path for sourcemap resolution, otherwise
                     // prefix with module path.
-                    filename: runtime === 'python'
+                    filename: isPython
                         ? pluginDebug
                             ? `${volume}/plugin.zip`
-                            : `${cwd}/plugin.zip`
+                            : zipFile
                         : pluginDebug
                             ? '/plugin/main.nodejs.js'
                             : `/${this.pluginId}/main.nodejs.js`,
+                    unzippedPath: this.unzippedPath,
                 };
-                const module = await remote.loadZip(plugin.packageJson, zipBuffer, loadZipOptions);
+                // original implementation sent the zipBuffer, sending the zipFile name now.
+                // can switch back for non-local plugins.
+                const modulePromise = remote.loadZip(this.packageJson, zipFile, loadZipOptions);
+                // allow garbage collection of the zip buffer
+                zipBuffer = undefined;
+                const module = await modulePromise;
                 logger.log('i', `loaded ${this.pluginName}`);
                 logger.clearAlert(fail)
                 return { module, remote };
@@ -260,27 +287,73 @@ export class PluginHost {
                 execArgv.push(`--inspect=0.0.0.0:${this.pluginDebug.inspectPort}`);
             }
 
-            this.worker = child_process.fork(require.main.filename, ['child'], {
-                stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-                env: Object.assign({}, process.env, env),
-                serialization: 'advanced',
-                execArgv,
-            });
-
-            this.peer = new RpcPeer('host', this.pluginId, (message, reject) => {
-                if (connected) {
-                    this.worker.send(message, undefined, e => {
-                        if (e && reject)
-                            reject(e);
+            const useSharedWorker = process.env.SCRYPTED_SHARED_WORKER &&
+                this.packageJson.scrypted.sharedWorker !== false &&
+                this.packageJson.scrypted.realfs !== true &&
+                Object.keys(this.packageJson.optionalDependencies || {}).length === 0;
+            if (useSharedWorker) {
+                if (!PluginHost.sharedWorker) {
+                    PluginHost.sharedWorker = 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.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);
                 }
-                else if (reject) {
-                    reject(new Error('peer disconnected'));
-                }
-            });
-            this.peer.transportSafeArgumentTypes.add(Buffer.name);
+                PluginHost.sharedWorker.send({
+                    type: 'start',
+                    pluginId: this.pluginId,
+                });
+                this.worker = PluginHost.sharedWorker;
+                this.worker.on('message', (message: any) => {
+                    if (message.pluginId === this.pluginId)
+                        this.peer.handleMessage(message.message)
+                });
+    
+                this.peer = new RpcPeer('host', this.pluginId, (message, reject) => {
+                    if (connected) {
+                        this.worker.send({
+                            type: 'message',
+                            pluginId: this.pluginId,
+                            message: message,
+                        }, undefined, e => {
+                            if (e && reject)
+                                reject(e);
+                        });
+                    }
+                    else if (reject) {
+                        reject(new Error('peer disconnected'));
+                    }
+                });
+            }
+            else {
+                this.worker = child_process.fork(require.main.filename, ['child', this.pluginId], {
+                    stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+                    env: Object.assign({}, process.env, env),
+                    serialization: 'advanced',
+                    execArgv,
+                });
+                this.worker.on('message', message => this.peer.handleMessage(message as any));
+    
+                this.peer = new RpcPeer('host', this.pluginId, (message, reject) => {
+                    if (connected) {
+                        this.worker.send(message, undefined, e => {
+                            if (e && reject)
+                                reject(e);
+                        });
+                    }
+                    else if (reject) {
+                        reject(new Error('peer disconnected'));
+                    }
+                });
+            }
 
-            this.worker.on('message', message => this.peer.handleMessage(message as any));
+            this.peer.transportSafeArgumentTypes.add(Buffer.name);
         }
 
         this.worker.stdout.on('data', data => console.log(data.toString()));
@@ -292,6 +365,10 @@ export class PluginHost {
             pluginConsole.log('starting plugin', this.pluginId, this.packageJson.version);
         });
 
+        this.worker.on('close', () => {
+            connected = false;
+            logger.log('e', `${this.pluginName} close`);
+        });
         this.worker.on('disconnect', () => {
             connected = false;
             logger.log('e', `${this.pluginName} disconnected`);
@@ -333,223 +410,3 @@ export class PluginHost {
         return setupPluginRemote(rpcPeer, api, null, () => this.scrypted.stateManager.getSystemState());
     }
 }
-
-export function startPluginRemote() {
-    const peer = new RpcPeer('unknown', 'host', (message, reject) => process.send(message, undefined, {
-        swallowErrors: !reject,
-    }, e => {
-        if (e)
-            reject?.(e);
-    }));
-    peer.transportSafeArgumentTypes.add(Buffer.name);
-    process.on('message', message => peer.handleMessage(message as RpcMessage));
-
-    let systemManager: SystemManager;
-    let deviceManager: DeviceManager;
-    let api: PluginAPI;
-    let pluginId: string;
-
-    const 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', 'time',
-            'timeEnd', '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;
-    }
-
-    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) => {
-            const plugins = await api.getComponent('plugins');
-            const connect = async () => {
-                const port = await plugins.getRemoteServicePort(peer.selfName, '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);
-    }
-
-    const getMixinConsole = (mixinId: string, nativeId: ScryptedNativeId) => {
-        return getConsole(async (stdout, stderr) => {
-            if (!mixinId) {
-                return;
-            }
-            // todo: fix this. a mixin provider can mixin another device to make it a mixin provider itself.
-            // so the mixin id in the mixin table will be incorrect.
-            // there's no easy way to fix this from the remote.
-            // if (!systemManager.getDeviceById(mixinId).mixins.includes(idForNativeId(nativeId))) {
-            //     return;
-            // }
-            const plugins = await systemManager.getComponent('plugins');
-            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 { 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}]`);
-    }
-
-    let lastCpuUsage: NodeJS.CpuUsage;
-    setInterval(() => {
-        const cpuUsage = process.cpuUsage(lastCpuUsage);
-        lastCpuUsage = cpuUsage;
-        peer.sendOob({
-            type: 'stats',
-            cpu: cpuUsage,
-            memoryUsage: process.memoryUsage(),
-        });
-        global?.gc();
-    }, 10000);
-
-    let replPort: Promise<number>;
-
-    let _pluginConsole: Console;
-    const getPluginConsole = () => {
-        if (!_pluginConsole)
-            _pluginConsole = getDeviceConsole(undefined);
-        return _pluginConsole;
-    }
-
-    attachPluginRemote(peer, {
-        createMediaManager: async (sm) => {
-            systemManager = sm;
-            return new MediaManagerImpl(systemManager, getPluginConsole());
-        },
-        onGetRemote: async (_api, _pluginId) => {
-            api = _api;
-            pluginId = _pluginId;
-            peer.selfName = pluginId;
-        },
-        onPluginReady: async (scrypted, params, plugin) => {
-            replPort = createREPLServer(scrypted, params, plugin);
-        },
-        getPluginConsole,
-        getDeviceConsole,
-        getMixinConsole,
-        async getServicePort(name, ...args: any[]) {
-            if (name === 'repl') {
-                if (!replPort)
-                    throw new Error('REPL unavailable: Plugin not loaded.')
-                return replPort;
-            }
-            throw new Error(`unknown service ${name}`);
-        },
-        async onLoadZip(zip: AdmZip, packageJson: any) {
-            installSourceMapSupport({
-                environment: 'node',
-                retrieveSourceMap(source) {
-                    if (source === '/plugin/main.nodejs.js' || source === `/${pluginId}/main.nodejs.js`) {
-                        const entry = zip.getEntry('main.nodejs.js.map')
-                        const map = entry?.getData().toString();
-                        if (!map)
-                            return null;
-                        return {
-                            url: '/plugin/main.nodejs.js',
-                            map,
-                        }
-                    }
-                    return null;
-                }
-            });
-            await installOptionalDependencies(getPluginConsole(), packageJson);
-        }
-    }).then(scrypted => {
-        systemManager = scrypted.systemManager;
-        deviceManager = scrypted.deviceManager;
-
-        process.on('uncaughtException', e => {
-            getPluginConsole().error('uncaughtException', e);
-            scrypted.log.e('uncaughtException ' + e?.toString());
-        });
-        process.on('unhandledRejection', e => {
-            getPluginConsole().error('unhandledRejection', e);
-            scrypted.log.e('unhandledRejection ' + e?.toString());
-        });
-    })
-}

package/src/plugin/plugin-http.ts

@@ -28,8 +28,8 @@ export abstract class PluginHttp<T> {
         });
     }
     
-    abstract handleEngineIOEndpoint(req: Request, res: ServerResponse, endpointRequest: HttpRequest, pluginData: T): Promise<void>;
-    abstract handleRequestEndpoint(req: Request, res: Response, endpointRequest: HttpRequest, pluginData: T): Promise<void>;
+    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 handleWebSocket(endpoint: string, httpRequest: HttpRequest, ws: WebSocket, pluginData: T): Promise<void>;
 
@@ -53,6 +53,7 @@ export abstract class PluginHttp<T> {
 
         if (!isPublicEndpoint && !res.locals.username) {
             end(401, 'Not Authorized');
+            console.log('rejected request', isPublicEndpoint, res.locals.username, req.originalUrl)
             return;
         }