@scrypted/server 0.0.134 → 0.0.135

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@scrypted/server",
-  "version": "0.0.134",
+  "version": "0.0.135",
   "description": "",
   "dependencies": {
-    "@mapbox/node-pre-gyp": "^1.0.5",
+    "@mapbox/node-pre-gyp": "^1.0.8",
     "@scrypted/ffmpeg": "^1.0.9",
-    "@scrypted/sdk": "^0.0.151",
+    "@scrypted/types": "^0.0.3",
     "adm-zip": "^0.5.3",
     "axios": "^0.21.1",
     "body-parser": "^1.19.0",
@@ -20,6 +20,7 @@
     "memfs": "^3.2.2",
     "mime-db": "^1.51.0",
     "mkdirp": "^1.0.4",
+    "nan": "^2.15.0",
     "node-dijkstra": "^2.5.0",
     "node-forge": "^1.2.0",
     "node-pty": "^0.10.1",
@@ -29,8 +30,7 @@
     "tar": "^6.1.11",
     "tmp": "^0.2.1",
     "tslib": "^2.3.1",
-    "typescript": "^4.4.4",
-    "werift": "^0.14.5",
+    "typescript": "^4.5.5",
     "whatwg-mimetype": "^2.3.0",
     "ws": "^8.2.3"
   },

package/python/plugin-remote.py

@@ -15,7 +15,7 @@ import asyncio
 import rpc
 from collections.abc import Mapping
 from scrypted_python.scrypted_sdk.types import DeviceManifest, MediaManager, ScryptedInterfaceProperty
-import scrypted_python.scrypted_sdk
+import scrypted_python.scrypted_sdk.types
 from asyncio.futures import Future
 from asyncio.streams import StreamReader, StreamWriter
 import os
@@ -30,7 +30,7 @@ class SystemDeviceState(TypedDict):
     value: any
 
 
-class SystemManager(scrypted_python.scrypted_sdk.SystemManager):
+class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
     def __init__(self, api: Any, systemState: Mapping[str, Mapping[str, SystemDeviceState]]) -> None:
         super().__init__()
         self.api = api
@@ -39,8 +39,8 @@ class SystemManager(scrypted_python.scrypted_sdk.SystemManager):
     async def getComponent(self, id: str) -> Any:
         return await self.api.getComponent(id)
 
-class DeviceState(scrypted_python.scrypted_sdk.DeviceState):
-    def __init__(self, id: str, nativeId: str, systemManager: SystemManager, deviceManager: scrypted_python.scrypted_sdk.DeviceManager) -> None:
+class DeviceState(scrypted_python.scrypted_sdk.types.DeviceState):
+    def __init__(self, id: str, nativeId: str, systemManager: SystemManager, deviceManager: scrypted_python.scrypted_sdk.types.DeviceManager) -> None:
         super().__init__()
         self._id = id
         self.nativeId = nativeId
@@ -80,7 +80,7 @@ class DeviceStorage:
     storage: Mapping[str, str] = {}
 
 
-class DeviceManager(scrypted_python.scrypted_sdk.DeviceManager):
+class DeviceManager(scrypted_python.scrypted_sdk.types.DeviceManager):
     def __init__(self, nativeIds: Mapping[str, DeviceStorage], systemManager: SystemManager) -> None:
         super().__init__()
         self.nativeIds = nativeIds

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,4 +1,4 @@
-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";

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,132 @@ 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;
+            }
+        });
     }
 
     abstract getSystemState(): { [id: string]: { [property: string]: SystemDeviceState } };
@@ -153,26 +178,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();
     }
 
@@ -194,25 +219,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);
+    }
+
+    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);
 
-        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();
+        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);
         }
-        else {
-            throw new Error('Unrecognized Scrypted Media interface.')
+
+        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)
+            }
+        }
+
+        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';

package/src/plugin/plugin-device.ts

@@ -1,7 +1,7 @@
-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 { MixinProvider } from "@scrypted/types";
 import { handleFunctionInvocations, PrimitiveProxyHandler } from "../rpc";
 import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";

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';