@scrypted/server 0.2.8 → 0.2.10

package/python/plugin-remote.py

@@ -4,6 +4,7 @@ import asyncio
 import base64
 import gc
 import json
+import mimetypes
 import os
 import platform
 import shutil
@@ -17,12 +18,11 @@ from asyncio.streams import StreamReader, StreamWriter
 from collections.abc import Mapping
 from io import StringIO
 from os import sys
-from typing import Any, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import aiofiles
 import scrypted_python.scrypted_sdk.types
 from scrypted_python.scrypted_sdk.types import (Device, DeviceManifest,
-                                                MediaManager,
                                                 ScryptedInterfaceProperty,
                                                 Storage)
 from typing_extensions import TypedDict
@@ -43,6 +43,50 @@ class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
     async def getComponent(self, id: str) -> Any:
         return await self.api.getComponent(id)
 
+class MediaObjectRemote(scrypted_python.scrypted_sdk.types.MediaObject):
+    def __init__(self, data, mimeType, sourceId):
+        self.mimeType = mimeType
+        self.data = data
+        setattr(self, '__proxy_props', {
+            'mimeType': mimeType,
+            'sourceId': sourceId,
+        })
+
+    async def getData(self):
+        return self.data
+
+class MediaManager:
+    def __init__(self, mediaManager: scrypted_python.scrypted_sdk.types.MediaManager):
+        self.mediaManager = mediaManager
+
+    async def addConverter(self, converter: scrypted_python.scrypted_sdk.types.BufferConverter) -> None:
+        return await self.mediaManager.addConverter(converter)
+    async def clearConverters(self) -> None:
+        return await self.mediaManager.clearConverters()
+    async def convertMediaObject(self, mediaObject: scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> Any:
+        return await self.mediaManager.convertMediaObject(mediaObject, toMimeType)
+    async def convertMediaObjectToBuffer(self, mediaObject: scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> bytearray:
+        return await self.mediaManager.convertMediaObjectToBuffer(mediaObject, toMimeType)
+    async def convertMediaObjectToInsecureLocalUrl(self, mediaObject: str | scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> str:
+        return await self.mediaManager.convertMediaObjectToInsecureLocalUrl(mediaObject, toMimeType)
+    async def convertMediaObjectToJSON(self, mediaObject: scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> Any:
+        return await self.mediaManager.convertMediaObjectToJSON(mediaObject, toMimeType)
+    async def convertMediaObjectToLocalUrl(self, mediaObject: str | scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> str:
+        return await self.mediaManager.convertMediaObjectToLocalUrl(mediaObject, toMimeType)
+    async def convertMediaObjectToUrl(self, mediaObject: str | scrypted_python.scrypted_sdk.types.MediaObject, toMimeType: str) -> str:
+        return await self.mediaManager.convertMediaObjectToUrl(mediaObject, toMimeType)
+    async def createFFmpegMediaObject(self, ffmpegInput: scrypted_python.scrypted_sdk.types.FFmpegInput, options: scrypted_python.scrypted_sdk.types.MediaObjectOptions = None) -> scrypted_python.scrypted_sdk.types.MediaObject:
+        return await self.mediaManager.createFFmpegMediaObject(ffmpegInput, options)
+    async def createMediaObject(self, data: Any, mimeType: str, options: scrypted_python.scrypted_sdk.types.MediaObjectOptions = None) -> scrypted_python.scrypted_sdk.types.MediaObject:
+        # return await self.createMediaObject(data, mimetypes, options)
+        return MediaObjectRemote(data, mimeType, options.get('sourceId', None) if options else None)
+    async def createMediaObjectFromUrl(self, data: str, options:scrypted_python.scrypted_sdk.types. MediaObjectOptions = None) -> scrypted_python.scrypted_sdk.types.MediaObject:
+        return await self.mediaManager.createMediaObjectFromUrl(data, options)
+    async def getFFmpegPath(self) -> str:
+        return await self.mediaManager.getFFmpegPath()
+    async def getFilesPath(self) -> str:
+        return await self.mediaManager.getFilesPath()
+
 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__()
@@ -139,13 +183,27 @@ class DeviceManager(scrypted_python.scrypted_sdk.types.DeviceManager):
         return self.nativeIds.get(nativeId, None)
 
 class BufferSerializer(rpc.RpcSerializer):
-    def serialize(self, value):
+    def serialize(self, value, serializationContext):
         return base64.b64encode(value).decode('utf8')
 
-    def deserialize(self, value):
+    def deserialize(self, value, serializationContext):
         return base64.b64decode(value)
 
 
+class SidebandBufferSerializer(rpc.RpcSerializer):
+    def serialize(self, value, serializationContext):
+        buffers = serializationContext.get('buffers', None)
+        if not buffers:
+            buffers = []
+            serializationContext['buffers'] = buffers
+        buffers.append(value)
+        return len(buffers) - 1
+
+    def deserialize(self, value, serializationContext):
+        buffers: List = serializationContext.get('buffers', None)
+        buffer = buffers.pop()
+        return buffer
+
 class PluginRemote:
     systemState: Mapping[str, Mapping[str, SystemDeviceState]] = {}
     nativeIds: Mapping[str, DeviceStorage] = {}
@@ -278,7 +336,7 @@ class PluginRemote:
         from scrypted_sdk import sdk_init  # type: ignore
         self.systemManager = SystemManager(self.api, self.systemState)
         self.deviceManager = DeviceManager(self.nativeIds, self.systemManager)
-        self.mediaManager = await self.api.getMediaManager()
+        self.mediaManager = MediaManager(await self.api.getMediaManager())
         sdk_init(zip, self, self.systemManager,
                  self.deviceManager, self.mediaManager)
         from main import create_scrypted_plugin  # type: ignore
@@ -329,29 +387,72 @@ class PluginRemote:
         pass
 
 
-async def readLoop(loop, peer, reader):
-    async for line in reader:
+async def readLoop(loop, peer: rpc.RpcPeer, reader):
+    deserializationContext = {
+        'buffers': []
+    }
+
+    while True:
         try:
-            message = json.loads(line)
-            asyncio.run_coroutine_threadsafe(peer.handleMessage(message), loop)
+            lengthBytes = await reader.read(4)
+            typeBytes = await reader.read(1)
+            type = typeBytes[0]
+            length = int.from_bytes(lengthBytes, 'big')
+            data = await reader.read(length - 1)
+
+            if type == 1:
+                deserializationContext['buffers'].append(data)
+                continue
+
+            message = json.loads(data)
+            asyncio.run_coroutine_threadsafe(peer.handleMessage(message, deserializationContext), loop)
+
+            deserializationContext = {
+                'buffers': []
+            }
         except Exception as e:
             print('read loop error', e)
             sys.exit()
 
 
 async def async_main(loop: AbstractEventLoop):
-    reader = await aiofiles.open(3, mode='r')
-
-    def send(message, reject=None):
-        jsonString = json.dumps(message)
-        try:
-            os.write(4, bytes(jsonString + '\n', 'utf8'))
-        except Exception as e:
-            if reject:
-                reject(e)
+    reader = await aiofiles.open(3, mode='rb')
+
+    mutex = threading.Lock()
+
+    def send(message, reject=None, serializationContext = None):
+        with mutex:
+            if serializationContext:
+                buffers = serializationContext.get('buffers', None)
+                if buffers:
+                    for buffer in buffers:
+                        length = len(buffer) + 1
+                        lb = length.to_bytes(4, 'big')
+                        type = 1
+                        try:
+                            os.write(4, lb)
+                            os.write(4, bytes([type]))
+                            os.write(4, buffer)
+                        except Exception as e:
+                            if reject:
+                                reject(e)
+                            return
+
+            jsonString = json.dumps(message)
+            b = bytes(jsonString, 'utf8')
+            length = len(b) + 1
+            lb = length.to_bytes(4, 'big')
+            type = 0
+            try:
+                os.write(4, lb)
+                os.write(4, bytes([type]))
+                os.write(4, b)
+            except Exception as e:
+                if reject:
+                    reject(e)
 
     peer = rpc.RpcPeer(send)
-    peer.nameDeserializerMap['Buffer'] = BufferSerializer()
+    peer.nameDeserializerMap['Buffer'] = SidebandBufferSerializer()
     peer.constructorSerializerMap[bytes] = 'Buffer'
     peer.constructorSerializerMap[bytearray] = 'Buffer'
     peer.params['print'] = print

package/python/rpc.py

@@ -1,5 +1,5 @@
 from asyncio.futures import Future
-from typing import Any, Callable, Mapping, List
+from typing import Any, Callable, Dict, Mapping, List
 import traceback
 import inspect
 from typing_extensions import TypedDict
@@ -31,10 +31,10 @@ class RpcResultException(Exception):
 
 
 class RpcSerializer:
-    def serialize(self, value):
+    def serialize(self, value, serializationContext):
         pass
 
-    def deserialize(self, value):
+    def deserialize(self, value, deserializationContext):
         pass
 
 
@@ -72,7 +72,7 @@ class RpcProxy(object):
 
     def __setattr__(self, name: str, value: Any) -> None:
         if name == '__proxy_finalizer_id':
-            self.dict['__proxy_entry']['finalizerId'] = value
+            self.__dict__['__proxy_entry']['finalizerId'] = value
 
         return super().__setattr__(name, value)
 
@@ -85,7 +85,7 @@ class RpcProxy(object):
 
 
 class RpcPeer:
-    def __init__(self, send: Callable[[object, Callable[[Exception], None]], None]) -> None:
+    def __init__(self, send: Callable[[object, Callable[[Exception], None], Dict], None]) -> None:
         self.send = send
         self.idCounter = 1
         self.peerName = 'Unnamed Peer'
@@ -99,9 +99,10 @@ class RpcPeer:
         self.nameDeserializerMap: Mapping[str, RpcSerializer] = {}
 
     def __apply__(self, proxyId: str, oneWayMethods: List[str], method: str, args: list):
+        serializationContext: Dict = {}
         serializedArgs = []
         for arg in args:
-            serializedArgs.append(self.serialize(arg, False))
+            serializedArgs.append(self.serialize(arg, False, serializationContext))
 
         rpcApply = {
             'type': 'apply',
@@ -113,25 +114,25 @@ class RpcPeer:
 
         if oneWayMethods and method in oneWayMethods:
             rpcApply['oneway'] = True
-            self.send(rpcApply)
+            self.send(rpcApply, None, serializationContext)
             future = Future()
             future.set_result(None)
             return future
 
         async def send(id: str, reject: Callable[[Exception], None]):
             rpcApply['id'] = id
-            self.send(rpcApply, reject)
+            self.send(rpcApply, reject, serializationContext)
         return self.createPendingResult(send)
 
     def kill(self):
         self.killed = True
 
-    def createErrorResult(self, result: any, name: str, message: str, tb: str):
+    def createErrorResult(self, result: Any, name: str, message: str, tb: str):
         result['stack'] = tb if tb else 'no stack'
         result['result'] = name if name else 'no name'
         result['message'] = message if message else 'no message'
 
-    def serialize(self, value, requireProxy):
+    def serialize(self, value, requireProxy, serializationContext: Dict):
         if (not value or (not requireProxy and type(value) in jsonSerializable)):
             return value
 
@@ -164,7 +165,7 @@ class RpcPeer:
         if serializerMapName:
             __remote_constructor_name = serializerMapName
             serializer = self.nameDeserializerMap.get(serializerMapName, None)
-            serialized = serializer.serialize(value)
+            serialized = serializer.serialize(value, serializationContext)
             ret = {
                 '__remote_proxy_id': None,
                 '__remote_proxy_finalizer_id': None,
@@ -216,7 +217,7 @@ class RpcPeer:
         weakref.finalize(proxy, lambda: self.finalize(localProxiedEntry))
         return proxy
 
-    def deserialize(self, value):
+    def deserialize(self, value, deserializationContext: Dict):
         if not value:
             return value
 
@@ -240,7 +241,7 @@ class RpcPeer:
             if not proxy:
                 proxy = self.newProxy(__remote_proxy_id, __remote_constructor_name,
                                       __remote_proxy_props, __remote_proxy_oneway_methods)
-            proxy.__proxy_finalizer_id = __remote_proxy_finalizer_id
+            setattr(proxy, '__proxy_finalizer_id', __remote_proxy_finalizer_id)
             return proxy
 
         if __local_proxy_id:
@@ -253,11 +254,11 @@ class RpcPeer:
         deserializer = self.nameDeserializerMap.get(
             __remote_constructor_name, None)
         if deserializer:
-            return deserializer.deserialize(__serialized_value)
+            return deserializer.deserialize(__serialized_value, deserializationContext)
 
         return value
 
-    async def handleMessage(self, message: any):
+    async def handleMessage(self, message: Any, deserializationContext: Dict):
         try:
             messageType = message['type']
             if messageType == 'param':
@@ -266,17 +267,18 @@ class RpcPeer:
                     'id': message['id'],
                 }
 
+                serializationContext: Dict = {}
                 try:
                     value = self.params.get(message['param'], None)
                     value = await maybe_await(value)
                     result['result'] = self.serialize(
-                        value, message.get('requireProxy', None))
+                        value, message.get('requireProxy', None), serializationContext)
                 except Exception as e:
                     tb = traceback.format_exc()
                     self.createErrorResult(
                         result, type(e).__name, str(e), tb)
 
-                self.send(result)
+                self.send(result, None, serializationContext)
 
             elif messageType == 'apply':
                 result = {
@@ -286,6 +288,7 @@ class RpcPeer:
                 method = message.get('method', None)
 
                 try:
+                    serializationContext: Dict = {}
                     target = self.localProxyMap.get(
                         message['proxyId'], None)
                     if not target:
@@ -294,7 +297,7 @@ class RpcPeer:
 
                     args = []
                     for arg in (message['args'] or []):
-                        args.append(self.deserialize(arg))
+                        args.append(self.deserialize(arg, deserializationContext))
 
                     value = None
                     if method:
@@ -306,7 +309,7 @@ class RpcPeer:
                     else:
                         value = await maybe_await(target(*args))
 
-                    result['result'] = self.serialize(value, False)
+                    result['result'] = self.serialize(value, False, serializationContext)
                 except Exception as e:
                     tb = traceback.format_exc()
                     # print('failure', method, e, tb)
@@ -314,7 +317,7 @@ class RpcPeer:
                         result, type(e).__name__, str(e), tb)
 
                 if not message.get('oneway', False):
-                    self.send(result)
+                    self.send(result, None, serializationContext)
 
             elif messageType == 'result':
                 id = message['id']
@@ -331,7 +334,7 @@ class RpcPeer:
                     future.set_exception(e)
                     return
                 future.set_result(self.deserialize(
-                    message.get('result', None)))
+                    message.get('result', None), deserializationContext))
             elif messageType == 'finalize':
                 finalizerId = message.get('__local_proxy_finalizer_id', None)
                 proxyId = message['__local_proxy_id']

package/src/mixin/mixin-cycle.ts

@@ -0,0 +1,31 @@
+import { ScryptedInterfaceProperty } from "@scrypted/types";
+import { ScryptedRuntime } from "../runtime";
+import { getState } from "../state";
+
+function getMixins(scrypted: ScryptedRuntime, id: string) {
+    const pluginDevice = scrypted.findPluginDeviceById(id);
+    if (!pluginDevice)
+        return [];
+    return getState(pluginDevice, ScryptedInterfaceProperty.mixins) || [];
+}
+
+export function hasMixinCycle(scrypted: ScryptedRuntime, id: string, mixins?: string[]) {
+    mixins = mixins || getMixins(scrypted, id);
+
+    // given the mixins for a device, find all the mixins for those mixins,
+    // and create a visited graph.
+    // if the visited graphs includes the original device, that indicates
+    // a cyclical dependency for that device.
+    const visitedMixins = new Set(mixins);
+
+    while (mixins.length) {
+        const mixin = mixins.pop();
+        if (visitedMixins.has(mixin))
+            continue;
+        visitedMixins.add(mixin);
+        const providerMixins = getMixins(scrypted, mixin);
+        mixins.push(...providerMixins);
+    }
+
+    return visitedMixins.has(id);
+}

package/src/plugin/media.ts

@@ -201,7 +201,17 @@ export abstract class MediaManagerBase implements MediaManager {
     getConverters(): IdBufferConverter[] {
         const converters = Object.entries(this.getSystemState())
             .filter(([id, state]) => state[ScryptedInterfaceProperty.interfaces]?.value?.includes(ScryptedInterface.BufferConverter))
-            .map(([id]) => this.getDeviceById<IdBufferConverter>(id));
+            .map(([id]) => {
+                const device = this.getDeviceById<BufferConverter>(id);
+                return {
+                    id,
+                    fromMimeType: device.fromMimeType,
+                    toMimeType: device.toMimeType,
+                    convert(data, fromMimeType, toMimeType, options?) {
+                        return device.convert(data, fromMimeType, toMimeType, options);
+                    },
+                } as IdBufferConverter;
+            });
 
         // builtins should be after system converters. these should not be overriden by system,
         // as it could cause system instability with misconfiguration.
@@ -328,7 +338,7 @@ export abstract class MediaManagerBase implements MediaManager {
             converterMap.set(c.id, c);
         }
 
-        const nodes: any = {};
+        const nodes: { [node: string]: { [edge: string]: number } } = {};
         const mediaNode: any = {};
         nodes['mediaObject'] = mediaNode;
         nodes['output'] = {};
@@ -341,7 +351,7 @@ export abstract class MediaManagerBase implements MediaManager {
                 // const convertedWeight = parseFloat(convertedMime.parameters.get('converter-weight')) || (convertedMime.essence === ScryptedMimeTypes.MediaObject ? 1000 : 1);
                 // const conversionWeight = inputWeight + convertedWeight;
                 const targetId = converter.id;
-                const node: any = nodes[targetId] = {};
+                const node: { [edge: string]: number } = nodes[targetId] = {};
 
                 // edge matches
                 for (const candidate of converters) {

package/src/plugin/plugin-host.ts

@@ -293,9 +293,9 @@ export class PluginHost {
             }
         }
 
-        this.peer = new RpcPeer('host', this.pluginId, (message, reject) => {
+        this.peer = new RpcPeer('host', this.pluginId, (message, reject, serializationContext) => {
             if (connected) {
-                this.worker.send(message, reject);
+                this.worker.send(message, reject, serializationContext);
             }
             else if (reject) {
                 reject(new Error('peer disconnected'));

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

@@ -397,7 +397,7 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
                 peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
 
                 if (zipOptions?.fork) {
-                    pluginConsole?.log('plugin forked');
+                    // pluginConsole?.log('plugin forked');
                     const fork = exports.fork;
                     const forked = await fork();
                     forked[RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION] = true;

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

@@ -1,4 +1,5 @@
 import { ScryptedInterface, ScryptedInterfaceProperty } from "@scrypted/types";
+import { RpcPeer } from "../rpc";
 import { propertyInterfaces } from "./descriptor";
 
 export function checkProperty(key: string, value: any) {
@@ -8,6 +9,8 @@ export function checkProperty(key: string, value: any) {
         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");
+    if (RpcPeer.isRpcProxy(value))
+        throw new Error('value must be a primitive type')
     const iface = propertyInterfaces[key.toString()];
     if (iface === ScryptedInterface.ScryptedDevice) {
         // only allow info to be set, since that doesn't actually change the descriptor

package/src/plugin/runtime/python-worker.ts

@@ -5,10 +5,12 @@ import path from 'path';
 import readline from 'readline';
 import { Readable, Writable } from 'stream';
 import { RpcMessage, RpcPeer } from "../../rpc";
+import { createRpcDuplexSerializer } from '../../rpc-serializer';
 import { ChildProcessWorker } from "./child-process-worker";
 import { RuntimeWorkerOptions } from "./runtime-worker";
 
 export class PythonRuntimeWorker extends ChildProcessWorker {
+    serializer: ReturnType<typeof createRpcDuplexSerializer>;
 
     constructor(pluginId: string, options: RuntimeWorkerOptions) {
         super(pluginId, options);
@@ -62,21 +64,24 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         const peerin = this.worker.stdio[3] as Writable;
         const peerout = this.worker.stdio[4] as Readable;
 
-        peerin.on('error', e => this.emit('error', e));
-        peerout.on('error', e => this.emit('error', e));
-
-        const readInterface = readline.createInterface({
-            input: peerout,
-            terminal: false,
+        const serializer = this.serializer = createRpcDuplexSerializer(peerin);
+        serializer.setupRpcPeer(peer);
+        peerout.on('data', data => serializer.onData(data));
+        peerin.on('error', e => {
+            this.emit('error', e);
+            serializer.onDisconnected();
+        });
+        peerout.on('error', e => {
+            this.emit('error', e)
+            serializer.onDisconnected();
         });
-        readInterface.on('line', line => peer.handleMessage(JSON.parse(line)));
     }
 
-    send(message: RpcMessage, reject?: (e: Error) => void): void {
+    send(message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any): void {
         try {
             if (!this.worker)
                 throw new Error('worked has been killed');
-            (this.worker.stdio[3] as Writable).write(JSON.stringify(message) + '\n', e => e && reject?.(e));
+            this.serializer.sendMessage(message, reject, serializationContext);
         }
         catch (e) {
             reject?.(e);

package/src/rpc.ts

@@ -84,7 +84,7 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
     }
 
     get(target: any, p: PropertyKey, receiver: any): any {
-        if (p === '__proxy_id')
+        if (p === RpcPeer.PROPERTY_PROXY_ID)
             return this.entry.id;
         if (p === '__proxy_constructor')
             return this.constructorName;
@@ -211,9 +211,15 @@ export class RpcPeer {
     nameDeserializerMap = new Map<string, RpcSerializer>();
     constructorSerializerMap = new Map<any, string>();
     transportSafeArgumentTypes = RpcPeer.getDefaultTransportSafeArgumentTypes();
+    killed: Promise<void>;
+    killedDeferred: Deferred;
 
     static readonly finalizerIdSymbol = Symbol('rpcFinalizerId');
 
+    static isRpcProxy(value: any) {
+        return !!value?.[RpcPeer.PROPERTY_PROXY_ID];
+    }
+
     static getDefaultTransportSafeArgumentTypes() {
         const jsonSerializable = new Set<string>();
         jsonSerializable.add(Number.name);
@@ -242,6 +248,7 @@ export class RpcPeer {
         }
     }
 
+    static readonly PROPERTY_PROXY_ID = '__proxy_id';
     static readonly PROPERTY_PROXY_ONEWAY_METHODS = '__proxy_oneway_methods';
     static readonly PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
     static readonly PROPERTY_PROXY_PROPERTIES = '__proxy_props';
@@ -259,6 +266,9 @@ export class RpcPeer {
     ]);
 
     constructor(public selfName: string, public peerName: string, public send: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void) {
+        this.killed = new Promise((resolve, reject) => {
+            this.killedDeferred = { resolve, reject };
+        });
     }
 
     createPendingResult(cb: (id: string, reject: (e: Error) => void) => void): Promise<any> {
@@ -280,6 +290,7 @@ export class RpcPeer {
 
     kill(message?: string) {
         const error = new RPCResultError(this, message || 'peer was killed');
+        this.killedDeferred.reject(error);
         for (const result of Object.values(this.pendingResults)) {
             result.reject(error);
         }

package/src/runtime.ts

@@ -20,6 +20,7 @@ import { getDisplayName, getDisplayRoom, getDisplayType, getProvidedNameOrDefaul
 import { IOServer } from './io';
 import { Level } from './level';
 import { LogEntry, Logger, makeAlertId } from './logger';
+import { hasMixinCycle } from './mixin/mixin-cycle';
 import { PluginDebug } from './plugin/plugin-debug';
 import { PluginDeviceProxyHandler } from './plugin/plugin-device';
 import { PluginHost } from './plugin/plugin-host';
@@ -812,6 +813,14 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
             }
         }
 
+        for (const id of Object.keys(this.stateManager.getSystemState())) {
+            if (hasMixinCycle(this, id)) {
+                console.warn(`initialize: ${id} has a mixin cycle. Clearing mixins.`);
+                const pluginDevice = this.findPluginDeviceById(id);
+                setState(pluginDevice, ScryptedInterfaceProperty.mixins, []);
+            }
+        }
+
         for await (const plugin of this.datastore.getAll(Plugin)) {
             try {
                 const pluginDevice = this.findPluginDevice(plugin._id);