@scrypted/server 0.0.71 → 0.0.78

package/src/plugin/plugin-host.ts

@@ -7,7 +7,7 @@ import io from 'engine.io';
 import { attachPluginRemote, setupPluginRemote } from './plugin-remote';
 import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { Logger } from '../logger';
-import { MediaManagerImpl } from './media';
+import { MediaManagerHostImpl, MediaManagerImpl } from './media';
 import { getState } from '../state';
 import WebSocket, { EventEmitter } from 'ws';
 import { listenZero } from './listen-zero';
@@ -18,7 +18,6 @@ import { PassThrough } from 'stream';
 import { Console } from 'console'
 import { sleep } from '../sleep';
 import { PluginHostAPI } from './plugin-host-api';
-import mkdirp from 'mkdirp';
 import path from 'path';
 import { install as installSourceMapSupport } from 'source-map-support';
 import net from 'net'
@@ -26,17 +25,8 @@ import child_process from 'child_process';
 import { PluginDebug } from './plugin-debug';
 import readline from 'readline';
 import { Readable, Writable } from 'stream';
-
-export function ensurePluginVolume(pluginId: string) {
-    const volume = path.join(process.cwd(), 'volume');
-    const pluginVolume = path.join(volume, 'plugins', pluginId);
-    try {
-        mkdirp.sync(pluginVolume);
-    }
-    catch (e) {
-    }
-    return pluginVolume;
-}
+import { ensurePluginVolume } from './plugin-volume';
+import { installOptionalDependencies } from './plugin-npm-dependencies';
 
 export class PluginHost {
     worker: child_process.ChildProcess;
@@ -58,8 +48,10 @@ export class PluginHost {
         cpuUsage: NodeJS.CpuUsage,
         memoryUsage: NodeJS.MemoryUsage,
     };
+    killed = false;
 
     kill() {
+        this.killed = true;
         this.listener.removeListener();
         this.api.removeListeners();
         this.worker.kill();
@@ -134,7 +126,12 @@ export class PluginHost {
 
         const self = this;
 
-        this.api = new PluginHostAPI(scrypted, plugin, this);
+        const { runtime } = this.packageJson.scrypted;
+        const mediaManager = runtime === 'python'
+            ? 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);
@@ -165,7 +162,6 @@ export class PluginHost {
                 }
             }
 
-            const { runtime } = this.packageJson.scrypted;
             const fail = 'Plugin failed to load. Console for more information.';
             try {
                 const loadZipOptions: PluginRemoteLoadZipOptions = {
@@ -192,8 +188,6 @@ export class PluginHost {
             }
         })();
 
-        init.catch(e => console.error('plugin failed to load', e));
-
         this.module = init.then(({ module }) => module);
         this.remote = new LazyRemote(remotePromise, init.then(({ remote }) => remote));
 
@@ -206,13 +200,20 @@ export class PluginHost {
                 this.remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, eventData, eventDetails.changed);
             }
         });
+
+        init.catch(e => {
+            console.error('plugin failed to load', e);
+            this.listener.removeListener();
+        });
     }
 
     startPluginClusterHost(logger: Logger, env?: any, runtime?: string) {
         let connected = true;
 
         if (runtime === 'python') {
-            const args: string[] = [];
+            const args: string[] = [
+                '-u',
+            ];
             if (this.pluginDebug) {
                 args.push(
                     '-m',
@@ -235,6 +236,9 @@ export class PluginHost {
             const peerin = this.worker.stdio[3] as Writable;
             const peerout = this.worker.stdio[4] as Readable;
 
+            peerin.on('error', e => connected = false);
+            peerout.on('error', e => connected = false);
+
             this.peer = new RpcPeer('host', this.pluginId, (message, reject) => {
                 if (connected) {
                     peerin.write(JSON.stringify(message) + '\n', e => e && reject?.(e));
@@ -281,10 +285,8 @@ export class PluginHost {
             this.worker.on('message', message => this.peer.handleMessage(message as any));
         }
 
-        this.worker.stdout.on('data', data => {
-            process.stdout.write(data);
-        });
-        this.worker.stderr.on('data', data => process.stderr.write(data));
+        this.worker.stdout.on('data', data => console.log(data.toString()));
+        this.worker.stderr.on('data', data => console.error(data.toString()));
 
         this.worker.on('disconnect', () => {
             connected = false;
@@ -470,28 +472,6 @@ export function startPluginClusterWorker() {
 
     const events = new EventEmitter();
 
-    events.once('zip', (zip: AdmZip, pluginId: string) => {
-        peer.selfName = pluginId;
-
-        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;
-            }
-        })
-    });
-
     let systemManager: SystemManager;
     let deviceManager: DeviceManager;
 
@@ -620,6 +600,36 @@ export function startPluginClusterWorker() {
             if (name === 'console-writer')
                 return (await consolePorts)[1];
             throw new Error(`unknown service ${name}`);
+        },
+        async beforeLoadZip(zip: AdmZip, packageJson: any) {
+            const pluginId = packageJson.name;
+            peer.selfName = pluginId;
+            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;
+                }
+            });
+            const cp = await consolePorts;
+            const writer = cp[1];
+            const socket = net.connect(writer);
+            await once(socket, 'connect');
+            try {
+                await installOptionalDependencies(pluginConsole, socket, packageJson);
+            }
+            finally {
+                socket.destroy();
+            }
         }
     }).then(scrypted => {
         systemManager = scrypted.systemManager;
@@ -648,10 +658,20 @@ class LazyRemote implements PluginRemote {
         })();
     }
 
+    async ensureRemote() {
+        try {
+            if (!this.remote)
+                await this.remoteReadyPromise;
+        }
+        catch (e) {
+            return;
+        }
+        return true;
+    }
+
     async loadZip(packageJson: any, zipData: Buffer, options?: PluginRemoteLoadZipOptions): Promise<any> {
         if (!this.remote)
             await this.remoteReadyPromise;
-
         return this.remote.loadZip(packageJson, zipData, options);
     }
     async setSystemState(state: { [id: string]: { [property: string]: SystemDeviceState; }; }): Promise<void> {
@@ -665,13 +685,13 @@ class LazyRemote implements PluginRemote {
         return this.remote.setNativeId(nativeId, id, storage);
     }
     async updateDeviceState(id: string, state: { [property: string]: SystemDeviceState; }): Promise<void> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
+        if (!await this.ensureRemote())
+            return;
         return this.remote.updateDeviceState(id, state);
     }
     async notify(id: string, eventTime: number, eventInterface: string, property: string, propertyState: SystemDeviceState, changed?: boolean): Promise<void> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
+        if (!await this.ensureRemote())
+            return;
         return this.remote.notify(id, eventTime, eventInterface, property, propertyState, changed);
     }
     async ioEvent(id: string, event: string, message?: any): Promise<void> {

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

@@ -0,0 +1,55 @@
+import { ensurePluginVolume } from "./plugin-volume";
+import fs from 'fs';
+import child_process from 'child_process';
+import path from 'path';
+import { once } from 'events';
+import { Socket } from "net";
+
+export async function installOptionalDependencies(console: Console, socket: Socket, packageJson: any) {
+    const pluginVolume = ensurePluginVolume(packageJson.name);
+    const optPj = path.join(pluginVolume, 'package.json');
+
+    let currentPackageJson: any;
+    try {
+        currentPackageJson = JSON.parse(fs.readFileSync(optPj).toString());
+    }
+    catch (e) {
+    }
+
+    const { optionalDependencies } = packageJson;
+    if (!optionalDependencies)
+        return;
+    if (!Object.keys(optionalDependencies).length)
+        return;
+    const currentOptionalDependencies = currentPackageJson?.dependencies || {};
+
+    if (JSON.stringify(optionalDependencies) === JSON.stringify(currentOptionalDependencies)) {
+        console.log('native dependencies (up to date).', ...Object.keys(optionalDependencies));
+        return;
+    }
+
+    console.log('native dependencies (outdated)', ...Object.keys(optionalDependencies));
+
+    const reduced = Object.assign({}, packageJson);
+    reduced.dependencies = reduced.optionalDependencies;
+    delete reduced.optionalDependencies;
+    delete reduced.devDependencies;
+
+    try {
+        fs.writeFileSync(optPj, JSON.stringify(reduced));
+
+        const cp = child_process.spawn('npm', ['--prefix', pluginVolume, 'install'], {
+            cwd: pluginVolume,
+            stdio: ['inherit', socket, socket],
+        });
+    
+        await once(cp, 'exit');
+        if (cp.exitCode !== 0)
+            throw new Error('npm installation failed with exit code ' + cp.exitCode);
+    }
+    catch (e) {
+        fs.rmSync(optPj);
+        throw e;
+    }
+    console.log('native dependencies installed.');
+}

package/src/plugin/plugin-remote.ts

@@ -4,7 +4,7 @@ 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 { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { SystemManagerImpl } from './system';
-import { RpcPeer, RPCResultError } from '../rpc';
+import { RpcPeer, RPCResultError, PROPERTY_PROXY_ONEWAY_METHODS, PROPERTY_JSON_DISABLE_SERIALIZATION  } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
 import { EventEmitter } from 'events';
 import { createWebSocketClass } from './plugin-remote-websocket';
@@ -285,6 +285,7 @@ export interface PluginRemoteAttachOptions {
     getDeviceConsole?: (nativeId?: ScryptedNativeId) => Console;
     getMixinConsole?: (id: string, nativeId?: ScryptedNativeId) => Console;
     events?: EventEmitter;
+    beforeLoadZip?: (zip: AdmZip, packageJson: any) => Promise<void>;
 }
 
 export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOptions): Promise<ScryptedStatic> {
@@ -324,9 +325,9 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
 
         const localStorage = new StorageImpl(deviceManager, undefined);
 
-        const remote: PluginRemote & { __proxy_required: boolean } = {
-            __proxy_required: true,
-            __proxy_oneway_methods: [
+        const remote: PluginRemote & { [PROPERTY_JSON_DISABLE_SERIALIZATION]: boolean, [PROPERTY_PROXY_ONEWAY_METHODS]: string[] } = {
+            [PROPERTY_JSON_DISABLE_SERIALIZATION]: true,
+            [PROPERTY_PROXY_ONEWAY_METHODS]: [
                 'notify',
                 'updateDeviceState',
                 'setSystemState',
@@ -401,11 +402,11 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                 done(ret);
             },
 
-            async loadZip(packageJson: any, zipData: Buffer, options?: PluginRemoteLoadZipOptions) {
+            async loadZip(packageJson: any, zipData: Buffer, zipOptions?: PluginRemoteLoadZipOptions) {
                 const pluginConsole = getDeviceConsole?.(undefined);
                 pluginConsole?.log('starting plugin', pluginId, packageJson.version);
                 const zip = new AdmZip(zipData);
-                events?.emit('zip', zip, pluginId);
+                await options?.beforeLoadZip?.(zip, packageJson);
                 const main = zip.getEntry('main.nodejs.js');
                 const script = main.getData().toString();
                 const window: any = {};
@@ -484,7 +485,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                 events?.emit('params', params);
 
                 try {
-                    peer.evalLocal(script, options?.filename || '/plugin/main.nodejs.js', params);
+                    peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
                     events?.emit('plugin', exports.default);
                     pluginConsole?.log('plugin successfully loaded');
                     return exports.default;

package/src/plugin/plugin-volume.ts

@@ -0,0 +1,13 @@
+import path from 'path';
+import mkdirp from 'mkdirp';
+
+export function ensurePluginVolume(pluginId: string) {
+    const volume = path.join(process.cwd(), 'volume');
+    const pluginVolume = path.join(volume, 'plugins', pluginId);
+    try {
+        mkdirp.sync(pluginVolume);
+    }
+    catch (e) {
+    }
+    return pluginVolume;
+}

package/src/plugin/system.ts

@@ -41,11 +41,15 @@ class DeviceProxyHandler implements ProxyHandler<any>, ScryptedDevice {
         return new Proxy(() => p, this);
     }
 
-    async apply(target: any, thisArg: any, argArray?: any) {
-        const method = target();
+    async ensureDevice() {
         if (!this.device)
             this.device = await this.systemManager.api.getDeviceById(this.id);
-        if (method === 'refresh') {
+    }
+
+    async apply(target: any, thisArg: any, argArray?: any) {
+        const method = target();
+        await this.ensureDevice();
+        if (false && method === 'refresh') {
             const name = this.systemManager.state[this.id]?.[ScryptedInterfaceProperty.name].value;
             this.systemManager.log.i(`requested refresh ${name}`);
         }
@@ -65,6 +69,10 @@ class DeviceProxyHandler implements ProxyHandler<any>, ScryptedDevice {
     async setType(type: ScryptedDeviceType): Promise<void> {
         return this.systemManager.api.setDeviceProperty(this.id, ScryptedInterfaceProperty.type, type);
     }
+
+    async probe(): Promise<boolean> {
+        return this.apply(() => 'probe', undefined, []);
+    }
 }
 
 

package/src/rpc.ts

@@ -22,7 +22,7 @@ interface RpcParam extends RpcMessage {
 interface RpcApply extends RpcMessage {
     id: string;
     proxyId: string;
-    argArray: any;
+    args: any[];
     method: string;
     oneway?: boolean;
 }
@@ -73,6 +73,9 @@ export function handleFunctionInvocations(thiz: ProxyHandler<any>, target: any,
 }
 
 export const PROPERTY_PROXY_ONEWAY_METHODS = '__proxy_oneway_methods';
+export const PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
+export const PROPERTY_PROXY_PROPERTIES = '__proxy_props';
+export const PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
 
 class RpcProxy implements ProxyHandler<any> {
     constructor(public peer: RpcPeer,
@@ -93,10 +96,12 @@ class RpcProxy implements ProxyHandler<any> {
             return this.constructorName;
         if (p === '__proxy_peer')
             return this.peer;
-        if (p === '__proxy_props')
+        if (p === PROPERTY_PROXY_PROPERTIES)
             return this.proxyProps;
         if (p === PROPERTY_PROXY_ONEWAY_METHODS)
             return this.proxyOneWayMethods;
+        if (p === PROPERTY_JSON_DISABLE_SERIALIZATION || p === PROPERTY_JSON_COPY_SERIALIZE_CHILDREN)
+            return;
         if (p === 'then')
             return;
         if (p === 'constructor')
@@ -120,7 +125,7 @@ class RpcProxy implements ProxyHandler<any> {
             type: "apply",
             id: undefined,
             proxyId: this.id,
-            argArray: args,
+            args,
             method,
         };
 
@@ -146,7 +151,7 @@ export class RPCResultError extends Error {
             this.name = options?.name;
         }
         if (options?.stack) {
-            this.stack = `${peer.peerName}:${peer.selfName}\n${options.stack.split('\n').slice(1).join('\n')}`;
+            this.stack = `${peer.peerName}:${peer.selfName}\n${cause?.stack || options.stack}`;
         }
     }
 }
@@ -279,6 +284,16 @@ export class RpcPeer {
     deserialize(value: any): any {
         if (!value)
             return value;
+
+        const copySerializeChildren = value[PROPERTY_JSON_COPY_SERIALIZE_CHILDREN];
+        if (copySerializeChildren) {
+            const ret: any = {};
+            for (const [key, val] of Object.entries(value)) {
+                ret[key] = this.deserialize(val);
+            }
+            return ret;
+        }
+
         const { __remote_proxy_id, __local_proxy_id, __remote_constructor_name, __serialized_value, __remote_proxy_props, __remote_proxy_oneway_methods } = value;
         if (__remote_proxy_id) {
             const proxy = this.remoteWeakProxies[__remote_proxy_id]?.deref() || this.newProxy(__remote_proxy_id, __remote_constructor_name, __remote_proxy_props, __remote_proxy_oneway_methods);
@@ -300,7 +315,15 @@ export class RpcPeer {
     }
 
     serialize(value: any): any {
-        if (!value || (!value.__proxy_required && this.transportSafeArgumentTypes.has(value.constructor?.name))) {
+        if (value?.[PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] === true) {
+            const ret: any = {};
+            for (const [key, val] of Object.entries(value)) {
+                ret[key] = this.serialize(val);
+            }
+            return ret;
+        }
+
+        if (!value || (!value[PROPERTY_JSON_DISABLE_SERIALIZATION] && this.transportSafeArgumentTypes.has(value.constructor?.name))) {
             return value;
         }
 
@@ -311,8 +334,8 @@ export class RpcPeer {
             const ret: RpcRemoteProxyValue = {
                 __remote_proxy_id: proxyId,
                 __remote_constructor_name,
-                __remote_proxy_props: value?.__proxy_props,
-                __remote_proxy_oneway_methods: value?.__proxy_oneway_methods,
+                __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
+                __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
             }
             return ret;
         }
@@ -333,8 +356,8 @@ export class RpcPeer {
             const ret: RpcRemoteProxyValue = {
                 __remote_proxy_id: undefined,
                 __remote_constructor_name,
-                __remote_proxy_props: value?.__proxy_props,
-                __remote_proxy_oneway_methods: value?.__proxy_oneway_methods,
+                __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
+                __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
                 __serialized_value: serialized,
             }
             return ret;
@@ -347,8 +370,8 @@ export class RpcPeer {
         const ret: RpcRemoteProxyValue = {
             __remote_proxy_id: proxyId,
             __remote_constructor_name,
-            __remote_proxy_props: value?.__proxy_props,
-            __remote_proxy_oneway_methods: value?.__proxy_oneway_methods,
+            __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
+            __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
         }
 
         return ret;
@@ -391,7 +414,7 @@ export class RpcPeer {
                             throw new Error(`proxy id ${rpcApply.proxyId} not found`);
 
                         const args = [];
-                        for (const arg of (rpcApply.argArray || [])) {
+                        for (const arg of (rpcApply.args || [])) {
                             args.push(this.deserialize(arg));
                         }
 

package/src/runtime.ts

@@ -1,5 +1,5 @@
 import { Level } from './level';
-import { ensurePluginVolume, PluginHost } from './plugin/plugin-host';
+import { PluginHost } from './plugin/plugin-host';
 import cluster from 'cluster';
 import { ScryptedNativeId, Device, EngineIOHandler, HttpRequest, HttpRequestHandler, OauthClient, PushHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty } from '@scrypted/sdk/types';
 import { PluginDeviceProxyHandler } from './plugin/plugin-device';
@@ -32,13 +32,14 @@ import {spawn as ptySpawn} from 'node-pty';
 import child_process from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { ensurePluginVolume } from './plugin/plugin-volume';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
     proxy: ScryptedDevice;
 }
 
-const MIN_SCRYPTED_CORE_VERSION = '0.0.135';
+const MIN_SCRYPTED_CORE_VERSION = 'v0.0.146';
 const PLUGIN_DEVICE_STATE_VERSION = 2;
 
 export class ScryptedRuntime {
@@ -427,33 +428,6 @@ export class ScryptedRuntime {
         return proxyPair;
     }
 
-    async installOptionalDependencies(packageJson: any, currentPackageJson: any) {
-        const { optionalDependencies } = packageJson;
-        if (!optionalDependencies)
-            return;
-        if (!Object.keys(packageJson).length)
-            return;
-        const currentOptionalDependencies = currentPackageJson?.optionalDependencies || {};
-
-        if (JSON.stringify(optionalDependencies) === JSON.stringify(currentOptionalDependencies))
-            return;
-        
-        const reduced = Object.assign({}, packageJson);
-        reduced.dependencies = reduced.optionalDependencies;
-        delete reduced.optionalDependencies;
-        delete reduced.devDependencies;
-
-        const pluginVolume = ensurePluginVolume(reduced.name);
-        const optPj = path.join(pluginVolume, 'package.json');
-        fs.writeFileSync(optPj, JSON.stringify(reduced));
-        const cp = child_process.spawn('npm', ['--prefix', pluginVolume, 'install'], {
-            cwd: pluginVolume,
-            stdio: 'inherit',
-        });
-
-        await once(cp, 'exit');
-    }
-
     async installNpm(pkg: string, version?: string): Promise<PluginHost> {
         const registry = (await axios(`https://registry.npmjs.org/${pkg}`)).data;
         if (!version) {
@@ -488,7 +462,6 @@ export class ScryptedRuntime {
             const packageJson = JSON.parse(packageJsonEntry.toString());
             const npmPackage = packageJson.name;
             const plugin = await this.datastore.tryGet(Plugin, npmPackage) || new Plugin();
-            await this.installOptionalDependencies(packageJson, plugin.packageJson);
 
             plugin._id = npmPackage;
             plugin.packageJson = packageJson;
@@ -542,6 +515,27 @@ export class ScryptedRuntime {
         }
 
         const pluginHost = new PluginHost(this, plugin, pluginDebug);
+        pluginHost.worker.once('exit', () => {
+            if (pluginHost.killed)
+                return;
+            pluginHost.kill();
+            console.error('plugin unexpectedly exited, restarting in 1 minute', pluginHost.pluginId);
+            setTimeout(async () => {
+                const existing = this.plugins[pluginHost.pluginId];
+                if (existing !== pluginHost) {
+                    console.log('scheduled plugin restart cancelled, plugin was restarted by user', pluginHost.pluginId);
+                    return;
+                }
+
+                const plugin = await this.datastore.tryGet(Plugin, pluginHost.pluginId);
+                if (!plugin) {
+                    console.log('scheduled plugin restart cancelled, plugin no longer exists', pluginHost.pluginId);
+                    return;
+                }
+
+                this.runPlugin(plugin).catch(e => console.error('error restarting plugin', plugin._id, e));
+            }, 60000);
+        })
         this.plugins[plugin._id] = pluginHost;
 
         return pluginHost;

package/src/scrypted-main.ts

@@ -1,7 +1,5 @@
 import path from 'path';
 import process from 'process';
-import pem from 'pem';
-import { CertificateCreationResult } from 'pem';
 import http from 'http';
 import https from 'https';
 import express from 'express';
@@ -26,12 +24,12 @@ import semver from 'semver';
 import { Info } from './services/info';
 import { getAddresses } from './addresses';
 import { sleep } from './sleep';
+import { createSelfSignedCertificate, CURRENT_SELF_SIGNED_CERTIFICATE_VERSION } from './cert';
 
 if (!semver.gte(process.version, '16.0.0')) {
     throw new Error('"node" version out of date. Please update node to v16 or higher.')
 }
 
-
 process.on('unhandledRejection', error => {
     if (error?.constructor !== RPCResultError) {
         throw error;
@@ -110,18 +108,6 @@ else {
     // parse some custom thing into a Buffer
     app.use(bodyParser.raw({ type: 'application/zip', limit: 100000000 }) as any)
 
-    async function createCertificate(options: pem.CertificateCreationOptions): Promise<pem.CertificateCreationResult> {
-        return new Promise((resolve, reject) => {
-            pem.createCertificate(options, (err: Error, keys: CertificateCreationResult) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve(keys);
-            })
-        })
-    }
-
     async function start() {
         const volumeDir = process.env.SCRYPTED_VOLUME || path.join(process.cwd(), 'volume');
         mkdirp.sync(volumeDir);
@@ -136,11 +122,8 @@ else {
 
         let certSetting = await db.tryGet(Settings, 'certificate') as Settings;
 
-        if (!certSetting) {
-            const cert = await createCertificate({
-                selfSigned: true,
-            });
-
+        if (certSetting?.value?.version !== CURRENT_SELF_SIGNED_CERTIFICATE_VERSION) {
+            const cert = createSelfSignedCertificate();
 
             certSetting = new Settings();
             certSetting._id = 'certificate';
@@ -167,6 +150,7 @@ else {
         });
 
         const keys = certSetting.value;
+
         const secure = https.createServer({ key: keys.serviceKey, cert: keys.certificate }, app);
         listenServerPort('SCRYPTED_SECURE_PORT', SCRYPTED_SECURE_PORT, secure);
         const insecure = http.createServer(app);
@@ -193,7 +177,7 @@ else {
         });
 
         // use a hash of the private key as the cookie secret.
-        app.use(cookieParser(crypto.createHash('sha256').update(certSetting.value.clientKey).digest().toString('hex')));
+        app.use(cookieParser(crypto.createHash('sha256').update(certSetting.value.serviceKey).digest().toString('hex')));
 
         app.all('*', async (req, res, next) => {
             // this is a trap for all auth.
@@ -316,9 +300,6 @@ else {
             const npmPackage = req.query.npmPackage as string;
             const plugin = await db.tryGet(Plugin, npmPackage) || new Plugin();
 
-            const packageJson = req.body;
-            await scrypted.installOptionalDependencies(packageJson, plugin.packageJson);
-
             plugin._id = npmPackage;
             plugin.packageJson = req.body;