@scrypted/server 0.0.165 → 0.0.168

package/python/plugin-repl.py

@@ -0,0 +1,9 @@
+from asyncore import write
+import code
+
+class ScryptedConsole(code.InteractiveConsole):
+    def write(self, data: str) -> None:
+        return super().write(data)
+
+    def raw_input(self, prompt: str) -> str:
+        return super().raw_input(prompt=prompt)

package/src/media-helpers.ts

@@ -11,7 +11,11 @@ export function safeKillFFmpeg(cp: ChildProcess) {
     if (!cp)
         return;
     // this will allow ffmpeg to send rtsp TEARDOWN etc
-    cp.stdin.write('q\n');
+    try {
+        cp.stdin.write('q\n');
+    }
+    catch (e) {
+    }
     setTimeout(() => {
         cp.kill();
         setTimeout(() => {

package/src/plugin/media.ts

@@ -1,19 +1,19 @@
-import { ScryptedInterfaceProperty, SystemDeviceState, MediaStreamUrl, BufferConverter, FFMpegInput, MediaManager, MediaObject, ScryptedInterface, ScryptedMimeTypes, SystemManager } from "@scrypted/types";
-import { MediaObjectRemote } from "./plugin-api";
-import mimeType from 'mime'
+import { getInstalledFfmpeg } from '@scrypted/ffmpeg';
+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 fs from 'fs';
-import tmp from 'tmp';
-import os from 'os';
-import { getInstalledFfmpeg } from '@scrypted/ffmpeg'
-import Graph from 'node-dijkstra';
-import MimeType from 'whatwg-mimetype';
-import axios from 'axios';
 import https from 'https';
-import rimraf from "rimraf";
+import mimeType from 'mime';
 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 { MediaObjectRemote } from "./plugin-api";
 
 function typeMatches(target: string, candidate: string): boolean {
     // candidate will accept anything
@@ -33,7 +33,7 @@ const httpsAgent = new https.Agent({
 export abstract class MediaManagerBase implements MediaManager {
     builtinConverters: BufferConverter[] = [];
 
-    constructor(public console: Console) {
+    constructor() {
         for (const h of ['http', 'https']) {
             this.builtinConverters.push({
                 fromMimeType: ScryptedMimeTypes.SchemePrefix + h,
@@ -56,7 +56,7 @@ export abstract class MediaManagerBase implements MediaManager {
             convert: async (data, fromMimeType, toMimeType) => {
                 const filename = data.toString();
                 const ab = await fs.promises.readFile(filename);
-                const mt =  mimeType.lookup(data.toString());
+                const mt = mimeType.lookup(data.toString());
                 const mo = this.createMediaObject(ab, mt);
                 return mo;
             }
@@ -67,7 +67,7 @@ export abstract class MediaManagerBase implements MediaManager {
             toMimeType: ScryptedMimeTypes.FFmpegInput,
             async convert(data, fromMimeType): Promise<Buffer> {
                 const url = data.toString();
-                const args: FFMpegInput = {
+                const args: FFmpegInput = {
                     url,
                     inputArguments: [
                         '-i', url,
@@ -96,13 +96,13 @@ export abstract class MediaManagerBase implements MediaManager {
                     '-i', mediaUrl.url,
                 ];
 
-                if (mediaUrl.url.startsWith('rtsp://')) {
+                if (mediaUrl.url.startsWith('rtsp')) {
                     inputArguments.unshift(
                         "-rtsp_transport", "tcp",
                     );
                 }
 
-                const ret: FFMpegInput = Object.assign({
+                const ret: FFmpegInput = Object.assign({
                     inputArguments,
                 }, mediaUrl);
 
@@ -121,8 +121,10 @@ export abstract class MediaManagerBase implements MediaManager {
         this.builtinConverters.push({
             fromMimeType: ScryptedMimeTypes.FFmpegInput,
             toMimeType: 'image/jpeg',
-            convert: async (data, fromMimeType: string): Promise<Buffer> => {
-                const ffInput: FFMpegInput = JSON.parse(data.toString());
+            convert: async (data, fromMimeType: string, toMimeType: string, options?: BufferConvertorOptions): Promise<Buffer> => {
+                const console = this.getMixinConsole(options?.sourceId, undefined);
+
+                const ffInput: FFmpegInput = JSON.parse(data.toString());
 
                 const args = [
                     '-hide_banner',
@@ -161,6 +163,8 @@ export abstract class MediaManagerBase implements MediaManager {
 
     abstract getSystemState(): { [id: string]: { [property: string]: SystemDeviceState } };
     abstract getDeviceById<T>(id: string): T;
+    abstract getPluginDeviceId(): string;
+    abstract getMixinConsole(mixinId: string, nativeId: ScryptedNativeId): Console;
 
     async getFFmpegPath(): Promise<string> {
         // try to get the ffmpeg path as a value of another variable
@@ -238,11 +242,7 @@ export abstract class MediaManagerBase implements MediaManager {
         return url.data.toString();
     }
 
-    async createFFmpegMediaObject(ffMpegInput: FFMpegInput): Promise<MediaObject> {
-        return this.createMediaObjectRemote(Buffer.from(JSON.stringify(ffMpegInput)), ScryptedMimeTypes.FFmpegInput);
-    }
-
-    createMediaObjectRemote(data: any | Buffer | Promise<string | Buffer>, mimeType: string): MediaObjectRemote {
+    createMediaObjectRemote(data: any | Buffer | Promise<string | Buffer>, mimeType: string, options?: MediaObjectOptions): MediaObjectRemote {
         if (typeof data === 'string')
             throw new Error('string is not a valid type. if you intended to send a url, use createMediaObjectFromUrl.');
         if (!mimeType)
@@ -253,12 +253,15 @@ export abstract class MediaManagerBase implements MediaManager {
         if (data.constructor.name !== Buffer.name)
             data = Buffer.from(JSON.stringify(data));
 
+        const sourceId = typeof options?.sourceId === 'string' ? options?.sourceId : this.getPluginDeviceId();
         class MediaObjectImpl implements MediaObjectRemote {
             __proxy_props = {
                 mimeType,
+                sourceId,
             }
 
             mimeType = mimeType;
+            sourceId = sourceId;
             async getData(): Promise<Buffer | string> {
                 return Promise.resolve(data);
             }
@@ -266,21 +269,24 @@ export abstract class MediaManagerBase implements MediaManager {
         return new MediaObjectImpl();
     }
 
-    async createMediaObject(data: any, mimeType: string): Promise<MediaObject> {
-        return this.createMediaObjectRemote(data, mimeType);
+    async createFFmpegMediaObject(ffMpegInput: FFmpegInput, options?: MediaObjectOptions): Promise<MediaObject> {
+        return this.createMediaObjectRemote(Buffer.from(JSON.stringify(ffMpegInput)), ScryptedMimeTypes.FFmpegInput, options);
     }
 
-    async createMediaObjectFromUrl(data: string): Promise<MediaObject> {
+    async createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObject> {
         const url = new URL(data);
         const scheme = url.protocol.slice(0, -1);
         const mimeType = ScryptedMimeTypes.SchemePrefix + scheme;
 
+        const sourceId = typeof options?.sourceId === 'string' ? options?.sourceId : this.getPluginDeviceId();
         class MediaObjectImpl implements MediaObjectRemote {
             __proxy_props = {
                 mimeType,
+                sourceId,
             }
 
             mimeType = mimeType;
+            sourceId = sourceId;
             async getData(): Promise<Buffer | string> {
                 return Promise.resolve(data);
             }
@@ -288,6 +294,10 @@ export abstract class MediaManagerBase implements MediaManager {
         return new MediaObjectImpl();
     }
 
+    async createMediaObject(data: any, mimeType: string, options?: MediaObjectOptions): Promise<MediaObject> {
+        return this.createMediaObjectRemote(data, mimeType, options);
+    }
+
     async convert(converters: BufferConverter[], mediaObject: MediaObjectRemote, toMimeType: string): Promise<{ data: Buffer | string | any, mimeType: string }> {
         // console.log('converting', mediaObject.mimeType, toMimeType);
         const mediaMime = new MimeType(mediaObject.mimeType);
@@ -300,6 +310,11 @@ export abstract class MediaManagerBase implements MediaManager {
             }
         }
 
+        let sourceId = mediaObject?.sourceId;
+        if (typeof sourceId !== 'string')
+            sourceId = this.getPluginDeviceId();
+        const console = this.getMixinConsole(sourceId, undefined);
+
         const converterIds = new Map<BufferConverter, string>();
         const converterReverseids = new Map<string, BufferConverter>();
         let id = 0;
@@ -363,6 +378,7 @@ export abstract class MediaManagerBase implements MediaManager {
         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);
@@ -372,7 +388,7 @@ export abstract class MediaManagerBase implements MediaManager {
             const targetMimeType = `${type}/${subtype}`;
 
             if (converter.toMimeType === ScryptedMimeTypes.MediaObject) {
-                const mo = await converter.convert(value, valueMime.essence, toMimeType) as MediaObject;
+                const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId }) as MediaObject;
                 const found = await this.convertMediaObjectToBuffer(mo, toMimeType);
                 return {
                     data: found,
@@ -380,7 +396,7 @@ export abstract class MediaManagerBase implements MediaManager {
                 };
             }
 
-            value = await converter.convert(value, valueMime.essence, targetMimeType) as string | Buffer;
+            value = await converter.convert(value, valueMime.essence, targetMimeType, { sourceId }) as string | Buffer;
             valueMime = new MimeType(targetMimeType);
         }
 
@@ -392,8 +408,8 @@ export abstract class MediaManagerBase implements MediaManager {
 }
 
 export class MediaManagerImpl extends MediaManagerBase {
-    constructor(public systemManager: SystemManager, console: Console) {
-        super(console);
+    constructor(public systemManager: SystemManager, public deviceManager: DeviceManager) {
+        super();
     }
 
     getSystemState(): { [id: string]: { [property: string]: SystemDeviceState; }; } {
@@ -403,16 +419,35 @@ export class MediaManagerImpl extends MediaManagerBase {
     getDeviceById<T>(id: string): T {
         return this.systemManager.getDeviceById<T>(id);
     }
+
+    getPluginDeviceId(): string {
+        return this.deviceManager.getDeviceState().id;
+    }
+
+    getMixinConsole(mixinId: string, nativeId: string): Console {
+        if (typeof mixinId !== 'string')
+            return this.deviceManager.getDeviceConsole(nativeId);
+        return this.deviceManager.getMixinConsole(mixinId, nativeId);
+    }
 }
 
 export class MediaManagerHostImpl extends MediaManagerBase {
-    constructor(public systemState: { [id: string]: { [property: string]: SystemDeviceState } },
-        public getDeviceById: (id: string) => any,
-        console: Console) {
-        super(console);
+    constructor(public pluginDeviceId: string,
+        public systemState: { [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;
+    }
+
+    getMixinConsole(mixinId: string, nativeId: string): Console {
+        return this.console;
+    }
 }

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

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest } from '@scrypted/types'
+import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest, ScryptedInterface } from '@scrypted/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
 import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';
@@ -7,6 +7,8 @@ import { getState } from '../state';
 import { PluginHost } from './plugin-host';
 import debounce from 'lodash/debounce';
 import { RpcPeer } from '../rpc';
+import { propertyInterfaces } from './descriptor';
+import { checkProperty } from './plugin-state-check';
 
 export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
     pluginId: string;
@@ -42,7 +44,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     // do we care about mixin validation here?
     // maybe to prevent/notify errant dangling events?
-    async onMixinEvent(id: string, nativeIdOrMixinDevice: ScryptedNativeId|any, eventInterface: any, eventData?: any) {
+    async onMixinEvent(id: string, nativeIdOrMixinDevice: ScryptedNativeId | any, eventInterface: any, eventData?: any) {
         // nativeId code path has been deprecated in favor of mixin object 12/10/2021
         const device = this.scrypted.findPluginDeviceById(id);
 
@@ -111,6 +113,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
     }
 
     async setState(nativeId: ScryptedNativeId, key: string, value: any) {
+        checkProperty(key, value);
         this.scrypted.stateManager.setPluginState(this.pluginId, nativeId, key, value);
     }
 

package/src/plugin/plugin-host.ts

@@ -1,29 +1,29 @@
-import { RpcPeer } from '../rpc';
+import { Device, EngineIOHandler } from '@scrypted/types';
 import AdmZip from 'adm-zip';
-import { Device, EngineIOHandler } from '@scrypted/types'
-import { ScryptedRuntime } from '../runtime';
-import { Plugin } from '../db-types';
+import crypto from 'crypto';
 import io, { Socket } from 'engine.io';
-import { setupPluginRemote } from './plugin-remote';
-import { PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
-import { Logger } from '../logger';
-import { MediaManagerHostImpl } from './media';
+import fs from 'fs';
+import mkdirp from 'mkdirp';
+import path from 'path';
+import rimraf from 'rimraf';
 import WebSocket from 'ws';
+import { Plugin } from '../db-types';
+import { Logger } from '../logger';
+import { RpcPeer } from '../rpc';
+import { ScryptedRuntime } from '../runtime';
 import { sleep } from '../sleep';
-import { PluginHostAPI } from './plugin-host-api';
-import path from 'path';
-import { PluginDebug } from './plugin-debug';
-import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
+import { MediaManagerHostImpl } from './media';
+import { PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { ConsoleServer, createConsoleServer } from './plugin-console';
+import { PluginDebug } from './plugin-debug';
+import { PluginHostAPI } from './plugin-host-api';
 import { LazyRemote } from './plugin-lazy-remote';
-import crypto from 'crypto';
-import fs from 'fs';
-import mkdirp from 'mkdirp';
-import rimraf from 'rimraf';
-import { RuntimeWorker } from './runtime/runtime-worker';
-import { PythonRuntimeWorker } from './runtime/python-worker';
+import { setupPluginRemote } from './plugin-remote';
+import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
 import { NodeForkWorker } from './runtime/node-fork-worker';
 import { NodeThreadWorker } from './runtime/node-thread-worker';
+import { PythonRuntimeWorker } from './runtime/python-worker';
+import { RuntimeWorker } from './runtime/runtime-worker';
 
 const serverVersion = require('../../package.json').version;
 
@@ -109,6 +109,7 @@ export class PluginHost {
         // allow garbage collection of the base 64 contents
         plugin = undefined;
 
+        const pluginDeviceId = scrypted.findPluginDevice(this.pluginId)._id;
         const logger = scrypted.getDeviceLogger(scrypted.findPluginDevice(this.pluginId));
 
         const volume = getScryptedVolume();
@@ -157,7 +158,7 @@ export class PluginHost {
 
         const { runtime } = this.packageJson.scrypted;
         const mediaManager = runtime === 'python'
-            ? new MediaManagerHostImpl(scrypted.stateManager.getSystemState(), id => scrypted.getDevice(id), console)
+            ? new MediaManagerHostImpl(pluginDeviceId, scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
             : undefined;
 
         this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager);

package/src/plugin/plugin-http.ts

@@ -94,15 +94,22 @@ export abstract class PluginHttp<T> {
         }
 
         if (!isEngineIOEndpoint && isUpgrade) {
-            this.wss.handleUpgrade(req, req.socket, (req as any).upgradeHead, async (ws) => {
-                try {
-                    await this.handleWebSocket(endpoint, httpRequest, ws, pluginData);
-                }
-                catch (e) {
-                    console.error('websocket plugin error', e);
-                    ws.close();
-                }
-            });
+            try {
+                this.wss.handleUpgrade(req, req.socket, (req as any).upgradeHead, async (ws) => {
+                    try {
+                        await this.handleWebSocket(endpoint, httpRequest, ws, pluginData);
+                    }
+                    catch (e) {
+                        console.error('websocket plugin error', e);
+                        ws.close();
+                    }
+                });
+            }
+            catch (e) {
+                res.status(500);
+                res.send(e.toString());
+                console.error(e);
+            }
         }
         else {
             try {

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

@@ -1,13 +1,13 @@
+import { DeviceManager, ScryptedNativeId, ScryptedStatic, SystemManager } from '@scrypted/types';
+import { Console } from 'console';
+import net from 'net';
+import { install as installSourceMapSupport } from 'source-map-support';
+import { PassThrough } from 'stream';
 import { RpcMessage, RpcPeer } from '../rpc';
-import { SystemManager, DeviceManager, ScryptedNativeId, ScryptedStatic } from '@scrypted/types'
-import { attachPluginRemote, PluginReader } from './plugin-remote';
-import { PluginAPI } from './plugin-api';
 import { MediaManagerImpl } from './media';
-import { PassThrough } from 'stream';
-import { Console } from 'console'
-import { install as installSourceMapSupport } from 'source-map-support';
-import net from 'net'
+import { PluginAPI } from './plugin-api';
 import { installOptionalDependencies } from './plugin-npm-dependencies';
+import { attachPluginRemote, PluginReader } from './plugin-remote';
 import { createREPLServer } from './plugin-repl';
 
 export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void) => void) {
@@ -172,9 +172,10 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
     let postInstallSourceMapSupport: (scrypted: ScryptedStatic) => void;
 
     attachPluginRemote(peer, {
-        createMediaManager: async (sm) => {
+        createMediaManager: async (sm, dm) => {
             systemManager = sm;
-            return new MediaManagerImpl(systemManager, getPluginConsole());
+            deviceManager = dm
+            return new MediaManagerImpl(systemManager, dm);
         },
         onGetRemote: async (_api, _pluginId) => {
             api = _api;

package/src/plugin/plugin-remote.ts

@@ -8,6 +8,8 @@ import { RpcPeer, RPCResultError } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
 import { createWebSocketClass, WebSocketConnectCallbacks, WebSocketMethods } from './plugin-remote-websocket';
 import fs from 'fs';
+import { checkProperty } from './plugin-state-check';
+import _ from 'lodash';
 const { link } = require('linkfs');
 
 class DeviceLogger implements Logger {
@@ -115,12 +117,7 @@ class DeviceStateProxyHandler implements ProxyHandler<any> {
     }
 
     set?(target: any, p: PropertyKey, value: any, receiver: any) {
-        if (p === ScryptedInterfaceProperty.id)
-            throw new Error("id is read only");
-        if (p === ScryptedInterfaceProperty.mixins)
-            throw new Error("mixins is read only");
-        if (p === ScryptedInterfaceProperty.interfaces)
-            throw new Error("interfaces is a read only post-mixin computed property, use providedInterfaces");
+        checkProperty(p.toString(), value);
         const now = Date.now();
         this.deviceManager.systemManager.state[this.id][p as string] = {
             lastEventTime: now,
@@ -183,6 +180,21 @@ class DeviceManagerImpl implements DeviceManager {
         }
         return ret;
     }
+    pruneMixinStorage() {
+        for (const nativeId of this.nativeIds.keys()) {
+            const storage = this.nativeIds.get(nativeId).storage;
+            for (const key of Object.keys(storage)) {
+                if (!key.startsWith('mixin:'))
+                    continue;
+                const [, id,] = key.split(':');
+                // there's no rush to persist this, it will happen automatically on the plugin
+                // persisting something at some point.
+                // the key itself is unreachable due to the device no longer existing.
+                if (id && !this.systemManager.state[id])
+                    delete storage[key];
+            }
+        }
+    }
     async onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData: any) {
         return this.api.onMixinEvent(id, nativeId, eventInterface, eventData);
     }
@@ -330,7 +342,7 @@ export interface WebSocketCustomHandler {
 export type PluginReader = (name: string) => Buffer;
 
 export interface PluginRemoteAttachOptions {
-    createMediaManager?: (systemManager: SystemManager) => Promise<MediaManager>;
+    createMediaManager?: (systemManager: SystemManager, deviceManager: DeviceManager) => Promise<MediaManager>;
     getServicePort?: (name: string, ...args: any[]) => Promise<number>;
     getDeviceConsole?: (nativeId?: ScryptedNativeId) => Console;
     getPluginConsole?: () => Console;
@@ -354,7 +366,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
         const systemManager = new SystemManagerImpl();
         const deviceManager = new DeviceManagerImpl(systemManager, getDeviceConsole, getMixinConsole);
         const endpointManager = new EndpointManagerImpl();
-        const mediaManager = await api.getMediaManager() || await createMediaManager(systemManager);
+        const mediaManager = await api.getMediaManager() || await createMediaManager(systemManager, deviceManager);
         peer.params['mediaManager'] = mediaManager;
         const ioSockets: { [id: string]: WebSocketConnectCallbacks } = {};
 
@@ -454,6 +466,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
 
             async setSystemState(state: { [id: string]: { [property: string]: SystemDeviceState } }) {
                 systemManager.state = state;
+                deviceManager.pruneMixinStorage();
                 done(ret);
             },
 

package/src/plugin/plugin-state-check.ts

@@ -0,0 +1,14 @@
+import { ScryptedInterface, ScryptedInterfaceProperty } from "@scrypted/types";
+import { propertyInterfaces } from "./descriptor";
+
+export function checkProperty(key: string, value: any) {
+    if (key === ScryptedInterfaceProperty.id)
+        throw new Error("id is read only");
+    if (key === ScryptedInterfaceProperty.mixins)
+        throw new Error("mixins is read only");
+    if (key === ScryptedInterfaceProperty.interfaces)
+        throw new Error("interfaces is a read only post-mixin computed property, use providedInterfaces");
+    const iface = propertyInterfaces[key.toString()];
+    if (iface === ScryptedInterface.ScryptedDevice)
+        throw new Error(`${key.toString()} can not be set. Use DeviceManager.onDevicesChanges or DeviceManager.onDeviceDiscovered to update the device description.`);
+}

package/src/plugin/system.ts

@@ -50,10 +50,6 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
     async apply(target: any, thisArg: any, argArray?: any) {
         const method = target();
         const device = await this.ensureDevice();
-        if (false && method === 'refresh') {
-            const name = this.systemManager.state[this.id]?.[ScryptedInterfaceProperty.name].value;
-            this.systemManager.log.i(`requested refresh ${name}`);
-        }
         return (device as any)[method](...argArray);
     }
 

package/src/runtime.ts

@@ -38,7 +38,7 @@ interface DeviceProxyPair {
     proxy: ScryptedDevice;
 }
 
-const MIN_SCRYPTED_CORE_VERSION = 'v0.0.217';
+const MIN_SCRYPTED_CORE_VERSION = 'v0.0.238';
 const PLUGIN_DEVICE_STATE_VERSION = 2;
 
 interface HttpPluginData {
@@ -431,7 +431,13 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
         return ret;
     }
 
-    async installNpm(pkg: string, version?: string): Promise<PluginHost> {
+    async installNpm(pkg: string, version?: string, installedSet?: Set<string>): Promise<PluginHost> {
+        if (!installedSet)
+            installedSet = new Set();
+        if (installedSet.has(pkg))
+            return;
+        installedSet.add(pkg);
+
         const registry = (await axios(`https://registry.npmjs.org/${pkg}`)).data;
         if (!version) {
             version = registry['dist-tags'].latest;
@@ -463,6 +469,20 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
             if (!packageJsonEntry)
                 throw new Error('package.json not found. are you behind a firewall?');
             const packageJson = JSON.parse(packageJsonEntry.toString());
+
+            const pluginDependencies: string[] = packageJson.scrypted.pluginDependencies || [];
+            pluginDependencies.forEach(async (dep) => {
+                try {
+                    const depId = this.findPluginDevice(dep);
+                    if (depId)
+                        throw new Error('Plugin already installed.');
+                    await this.installNpm(dep);
+                }
+                catch (e) {
+                    console.log('Skipping', dep, ':', e.message);
+                }
+            });
+
             const npmPackage = packageJson.name;
             const plugin = await this.datastore.tryGet(Plugin, npmPackage) || new Plugin();
 
@@ -745,6 +765,11 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                 setState(pluginDevice, ScryptedInterfaceProperty.providedInterfaces, PluginDeviceProxyHandler.sortInterfaces(interfaces));
             }
 
+            if (!pluginDevice.pluginId) {
+                dirty = true;
+                setState(pluginDevice, ScryptedInterfaceProperty.pluginId, pluginDevice.pluginId);
+            }
+
             if (dirty) {
                 this.datastore.upsert(pluginDevice);
             }

package/src/scrypted-server-main.ts

@@ -231,11 +231,6 @@ async function start() {
     }
     console.log(`Version:       : ${await new Info().getVersion()}`);
     console.log('#######################################################');
-    console.log('Chrome Users: You may need to type "thisisunsafe" into')
-    console.log('              the window to bypass the warning. There')
-    console.log('              may be no button to continue, type the')
-    console.log('              letters "thisisunsafe" and it will proceed.')
-    console.log('#######################################################');
     console.log('Scrypted insecure http service port:', SCRYPTED_INSECURE_PORT);
     console.log('Ports can be changed with environment variables.')
     console.log('https: $SCRYPTED_SECURE_PORT')

package/src/services/plugin.ts

@@ -121,6 +121,11 @@ export class PluginComponent {
             try {
                 const registry = await this.npmInfo(plugin);
                 const version = registry['dist-tags'].latest;
+                if (registry?.versions?.[version]?.deprecated) {
+                    console.log('plugin deprecated, uninstalling:', plugin);
+                    await this.scrypted.removeDevice(this.scrypted.findPluginDevice(plugin));
+                    continue;
+                }
                 if (!semver.gt(version, host.packageJson.version)) {
                     console.log('plugin up to date:', plugin);
                     continue;

package/src/state.ts

@@ -169,9 +169,10 @@ export class ScryptedStateManager extends EventRegistry {
 
                 await sleep(timeout);
                 try {
-                    if (!ret.tailRefresh)
+                    const rt = this.refreshThrottles[id];
+                    if (!rt.tailRefresh)
                         return;
-                    await device[RefreshSymbol](ret.refreshInterface, ret.userInitiated);
+                    await device[RefreshSymbol](rt.refreshInterface, rt.userInitiated);
                 }
                 catch (e) {
                     logger.log('e', 'Refresh failed');