@scrypted/server 0.0.134 → 0.0.139

package/src/db-types.ts

@@ -1,5 +1,5 @@
 import { LevelDocument } from "./level";
-import { ScryptedNativeId, SystemDeviceState } from "@scrypted/sdk/types";
+import { ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
 
 export class ScryptedDocument implements LevelDocument {
     _id?: string;

package/src/event-registry.ts

@@ -1,4 +1,4 @@
-import { EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterface, SystemDeviceState } from "@scrypted/sdk/types";
+import { EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterface, SystemDeviceState } from "@scrypted/types";
 
 export class EventListenerRegisterImpl implements EventListenerRegister {
     removeListener: () => void;

package/src/http-interfaces.ts

@@ -1,13 +1,14 @@
-import { HttpResponse, HttpResponseOptions } from "@scrypted/sdk/types";
+import { HttpResponse, HttpResponseOptions } from "@scrypted/types";
 import { Response } from "express";
-import mime from "mime";
-import { PROPERTY_PROXY_ONEWAY_METHODS } from "./rpc";
+import { RpcPeer } from "./rpc";
 import { join as pathJoin } from 'path';
 import fs from 'fs';
 
+const  mime = require('mime/lite');
+
 export function createResponseInterface(res: Response, unzippedDir: string): HttpResponse {
     class HttpResponseImpl implements HttpResponse {
-        [PROPERTY_PROXY_ONEWAY_METHODS] = [
+        [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = [
             'send',
             'sendFile',
         ];
@@ -39,8 +40,12 @@ export function createResponseInterface(res: Response, unzippedDir: string): Htt
                 }
             }
 
-            if (!res.getHeader('Content-Type'))
-                res.contentType(mime.lookup(path));
+            if (!res.getHeader('Content-Type')) {
+                const type = mime.getType(path);
+                if (type) {
+                    res.contentType(mime.getExtension(type));
+                }
+            }
 
             const filePath = pathJoin(unzippedDir, 'fs', path);
             if (!fs.existsSync(filePath)) {

package/src/infer-defaults.ts

@@ -1,4 +1,4 @@
-import { ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceProperty } from "@scrypted/sdk/types";
+import { ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceProperty } from "@scrypted/types";
 import { PluginDevice } from "./db-types";
 import { getState } from "./state";
 

package/src/media-helpers.ts

@@ -1,6 +1,5 @@
 import { ChildProcess } from "child_process";
-import { MediaStreamOptions, VideoCamera } from "@scrypted/sdk";
-
+import process from 'process';
 
 const filtered = [
     'decode_slice_header error',
@@ -8,7 +7,9 @@ const filtered = [
     'non-existing PPS',
 ];
 
-export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forever?: boolean) {
+export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forever?: boolean, storage?: Storage) {
+    const SCRYPTED_FFMPEG_NOISY = !!process.env.SCRYPTED_FFMPEG_NOISY || !!storage?.getItem('SCRYPTED_FFMPEG_NOISY');
+
     function logger(log: (str: string) => void): (buffer: Buffer) => void {
         const ret = (buffer: Buffer) => {
             const str = buffer.toString();
@@ -18,7 +19,7 @@ export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forev
                     return;
             }
 
-            if (!forever && (str.indexOf('frame=') !== -1 || str.indexOf('size=') !== -1)) {
+            if (!SCRYPTED_FFMPEG_NOISY && !forever && (str.indexOf('frame=') !== -1 || str.indexOf('size=') !== -1)) {
                 log(str);
                 log('video/audio detected, discarding further input');
                 cp.stdout.removeListener('data', ret);
@@ -36,34 +37,12 @@ export function ffmpegLogInitialOutput(console: Console, cp: ChildProcess, forev
     cp.on('exit', () => console.log('ffmpeg exited'));
 }
 
-export async function probeVideoCamera(device: VideoCamera) {
-    let options: MediaStreamOptions[];
-    try {
-      options = await device.getVideoStreamOptions() || [];
-    }
-    catch (e) {
-    }
-
-    // todo: uses the first stream to determine audio availability. buggy! fix this!
-    const noAudio = options && options.length && options[0].audio === null;
-    return {
-        options,
-        noAudio,
-    };
-}
-
 export function safePrintFFmpegArguments(console: Console, args: string[]) {
     const ret = [];
     for (const arg of args) {
         try {
             const url = new URL(arg);
-            if (url.password) {
-                url.password = 'REDACTED';
-                ret.push(url.toString());
-            }
-            else {
-                ret.push(arg);
-            }
+            ret.push(`${url.protocol}[REDACTED]`)
         }
         catch (e) {
             ret.push(arg);

package/src/plugin/descriptor.ts

@@ -1,4 +1,4 @@
-import { ScryptedInterface, ScryptedInterfaceDescriptors } from "@scrypted/sdk/types";
+import { ScryptedInterface, ScryptedInterfaceDescriptors } from "@scrypted/types";
 
 export const allInterfaceMethods: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map((type: any) => type.methods));
 export const allInterfaceProperties: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map((type: any) => type.properties));

package/src/plugin/media.ts

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

package/src/plugin/plugin-api.ts

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

package/src/plugin/plugin-console.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId } from '@scrypted/sdk/types'
+import { ScryptedNativeId } from '@scrypted/types'
 import { listenZero } from './listen-zero';
 import { Server } from 'net';
 import { once } from 'events';
@@ -10,9 +10,7 @@ export interface ConsoleServer {
     pluginConsole: Console;
     readPort: number,
     writePort: number,
-    readServer: net.Server,
-    writeServer: net.Server,
-    sockets: Set<net.Socket>;
+    destroy(): void;
 }
 
 export interface StdPassThroughs {
@@ -129,11 +127,22 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
     const writePort = await listenZero(writeServer);
 
     return {
+        destroy() {
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+            sockets.clear();
+            outputs.clear();
+
+            try {
+                readServer.close();
+                writeServer.close();
+            }
+            catch (e) {
+            }
+        },
         pluginConsole,
         readPort,
         writePort,
-        readServer,
-        writeServer,
-        sockets,
     };
 }

package/src/plugin/plugin-device.ts

@@ -1,8 +1,8 @@
-import { DeviceProvider, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/sdk/types";
+import { DeviceProvider, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/types";
 import { ScryptedRuntime } from "../runtime";
 import { PluginDevice } from "../db-types";
-import { MixinProvider } from "@scrypted/sdk/types";
-import { handleFunctionInvocations, PrimitiveProxyHandler } from "../rpc";
+import { MixinProvider } from "@scrypted/types";
+import { RpcPeer, PrimitiveProxyHandler } from "../rpc";
 import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";
 import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from "./descriptor";
@@ -285,7 +285,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
     get(target: any, p: PropertyKey, receiver: any): any {
         if (p === 'constructor')
             return;
-        const handled = handleFunctionInvocations(this, target, p, receiver);
+        const handled = RpcPeer.handleFunctionInvocations(this, target, p, receiver);
         if (handled)
             return handled;
         const pluginDevice = this.scrypted.findPluginDeviceById(this.id);

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

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest } from '@scrypted/sdk/types'
+import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest } from '@scrypted/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
 import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';
@@ -6,12 +6,12 @@ import { Logger } from '../logger';
 import { getState } from '../state';
 import { PluginHost } from './plugin-host';
 import debounce from 'lodash/debounce';
-import { PROPERTY_PROXY_ONEWAY_METHODS } from '../rpc';
+import { RpcPeer } from '../rpc';
 
 export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
     pluginId: string;
 
-    [PROPERTY_PROXY_ONEWAY_METHODS] = [
+    [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = [
         'onMixinEvent',
         'onDeviceEvent',
         'setStorage',