@scrypted/server 0.1.15 → 0.2.2

package/src/plugin/plugin-device.ts

@@ -216,15 +216,24 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
         let { allInterfaces } = await previousEntry;
         try {
             const mixinProvider = this.scrypted.getDevice(mixinId) as ScryptedDevice & MixinProvider;
-            const interfaces = mixinProvider?.interfaces?.includes(ScryptedInterface.MixinProvider) && await mixinProvider?.canMixin(type, allInterfaces) as any as ScryptedInterface[];
+            const isMixinProvider = mixinProvider?.interfaces?.includes(ScryptedInterface.MixinProvider);
+            const interfaces = isMixinProvider && await mixinProvider?.canMixin(type, allInterfaces) as any as ScryptedInterface[];
             if (!interfaces) {
                 // this is not an error
                 // do not advertise interfaces so it is skipped during
                 // vtable lookup.
-                console.log(`mixin provider ${mixinId} can no longer mixin ${this.id}`);
-                const mixins: string[] = getState(pluginDevice, ScryptedInterfaceProperty.mixins) || [];
-                this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.mixins, mixins.filter(mid => mid !== mixinId))
-                this.scrypted.datastore.upsert(pluginDevice);
+                if (!mixinProvider || (isMixinProvider && !interfaces)) {
+                    console.log(`Mixin provider ${mixinId} can no longer mixin ${this.id}. Removing.`, {
+                        mixinProvider: !!mixinProvider,
+                        interfaces,
+                    });
+                    const mixins: string[] = getState(pluginDevice, ScryptedInterfaceProperty.mixins) || [];
+                    this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.mixins, mixins.filter(mid => mid !== mixinId))
+                    this.scrypted.datastore.upsert(pluginDevice);
+                }
+                else {
+                    console.log(`Mixin provider ${mixinId} can not mixin ${this.id}. It is no longer a MixinProvider. This may be temporary. Passing through.`);
+                }
                 return {
                     passthrough: true,
                     allInterfaces,
@@ -353,12 +362,17 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
         for (const mixin of this.mixinTable) {
             const entry = await mixin.entry;
             if (!entry.methods) {
-                const pluginDevice = this.scrypted.findPluginDeviceById(mixin.mixinProviderId || this.id);
-                const plugin = this.scrypted.plugins[pluginDevice.pluginId];
-                let methods = new Set<string>(getInterfaceMethods(ScryptedInterfaceDescriptors, entry.interfaces))
-                if (plugin.api.descriptors)
-                    methods = new Set<string>([...methods, ...getInterfaceMethods(plugin.api.descriptors, entry.interfaces)]);
-                entry.methods = methods;
+                if (entry.interfaces.size) {
+                    const pluginDevice = this.scrypted.findPluginDeviceById(mixin.mixinProviderId || this.id);
+                    const plugin = this.scrypted.plugins[pluginDevice.pluginId];
+                    let methods = new Set<string>(getInterfaceMethods(ScryptedInterfaceDescriptors, entry.interfaces))
+                    if (plugin.api.descriptors)
+                        methods = new Set<string>([...methods, ...getInterfaceMethods(plugin.api.descriptors, entry.interfaces)]);
+                    entry.methods = methods;
+                }
+                else {
+                    entry.methods = new Set();
+                }
             }
             if (entry.methods.has(method)) {
                 return { mixin, entry };

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

@@ -47,7 +47,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: string, eventData?: any) {
         // nativeId code path has been deprecated in favor of mixin object 12/10/2021
         const device = this.scrypted.findPluginDeviceById(id);
 

package/src/plugin/plugin-host.ts

@@ -135,7 +135,7 @@ export class PluginHost {
         this.io.on('connection', async (socket) => {
             try {
                 try {
-                    if (socket.request.url.indexOf('/api') !== -1) {
+                    if (socket.request.url.indexOf('/engine.io/api') !== -1) {
                         if (socket.request.url.indexOf('/public') !== -1) {
                             socket.close();
                             return;
@@ -179,7 +179,7 @@ export class PluginHost {
 
         const { runtime } = this.packageJson.scrypted;
         const mediaManager = runtime === 'python'
-            ? new MediaManagerHostImpl(pluginDeviceId, scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
+            ? new MediaManagerHostImpl(pluginDeviceId, () => scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
             : undefined;
 
         this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager);
@@ -214,7 +214,6 @@ export class PluginHost {
                 await remote.setNativeId(pluginDevice.nativeId, pluginDevice._id, pluginDevice.storage || {});
             }
 
-            await remote.setSystemState(scrypted.stateManager.getSystemState());
             const waitDebug = pluginDebug?.waitDebug;
             if (waitDebug) {
                 console.info('waiting for debugger...');
@@ -374,7 +373,8 @@ export class PluginHost {
         serializer.setupRpcPeer(rpcPeer);
 
         // wrap the host api with a connection specific api that can be torn down on disconnect
-        const api = new PluginAPIProxy(this.api, await this.peer.getParam('mediaManager'));
+        const createMediaManager = await this.peer.getParam('createMediaManager');
+        const api = new PluginAPIProxy(this.api, await createMediaManager());
         const kill = () => {
             serializer.onDisconnected();
             api.removeListeners();
@@ -389,7 +389,8 @@ export class PluginHost {
         const rpcPeer = createDuplexRpcPeer(`api/${this.pluginId}`, 'duplex', duplex, duplex);
 
         // wrap the host api with a connection specific api that can be torn down on disconnect
-        const api = new PluginAPIProxy(this.api, await this.peer.getParam('mediaManager'));
+        const createMediaManager = await this.peer.getParam('createMediaManager');
+        const api = new PluginAPIProxy(this.api, await createMediaManager());
         const kill = () => {
             api.removeListeners();
         };

package/src/plugin/plugin-http.ts

@@ -38,7 +38,7 @@ export abstract class PluginHttp<T> {
 
     abstract handleEngineIOEndpoint(req: Request, res: ServerResponse, endpointRequest: HttpRequest, pluginData: T): void;
     abstract handleRequestEndpoint(req: Request, res: Response, endpointRequest: HttpRequest, pluginData: T): void;
-    abstract getEndpointPluginData(endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T>;
+    abstract getEndpointPluginData(req: Request, endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T>;
     abstract handleWebSocket(endpoint: string, httpRequest: HttpRequest, ws: WebSocket, pluginData: T): Promise<void>;
 
     async endpointHandler(req: Request, res: Response, isPublicEndpoint: boolean, isEngineIOEndpoint: boolean,
@@ -75,7 +75,7 @@ export abstract class PluginHttp<T> {
             return;
         }
 
-        const pluginData = await this.getEndpointPluginData(endpoint, isUpgrade, isEngineIOEndpoint);
+        const pluginData = await this.getEndpointPluginData(req, endpoint, isUpgrade, isEngineIOEndpoint);
         if (!pluginData) {
             end(404, 'Not Found');
             return;

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

@@ -1,20 +1,32 @@
 import { DeviceManager, ScryptedNativeId, ScryptedStatic, SystemManager } from '@scrypted/types';
+import AdmZip from 'adm-zip';
 import { Console } from 'console';
+import fs from 'fs';
+import { Volume } from 'memfs';
 import net from 'net';
+import path from 'path';
 import { install as installSourceMapSupport } from 'source-map-support';
 import { PassThrough } from 'stream';
 import { RpcMessage, RpcPeer } from '../rpc';
 import { MediaManagerImpl } from './media';
-import { PluginAPI } from './plugin-api';
+import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { installOptionalDependencies } from './plugin-npm-dependencies';
-import { attachPluginRemote, PluginReader } from './plugin-remote';
+import { attachPluginRemote, DeviceManagerImpl, PluginReader, setupPluginRemote } from './plugin-remote';
 import { createREPLServer } from './plugin-repl';
+import { NodeThreadWorker } from './runtime/node-thread-worker';
+const { link } = require('linkfs');
 
-export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void) => void) {
+interface PluginStats {
+    type: 'stats',
+    cpu: NodeJS.CpuUsage;
+    memoryUsage: NodeJS.MemoryUsage;
+}
+
+export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void) {
     const peer = new RpcPeer('unknown', 'host', peerSend);
 
     let systemManager: SystemManager;
-    let deviceManager: DeviceManager;
+    let deviceManager: DeviceManagerImpl;
     let api: PluginAPI;
 
     const getConsole = (hook: (stdout: PassThrough, stderr: PassThrough) => Promise<void>,
@@ -66,13 +78,18 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
         return pluginsPromise;
     }
 
+    const deviceConsoles = new Map<string, Console>();
     const getDeviceConsole = (nativeId?: ScryptedNativeId) => {
         // the the plugin console is simply the default console
         // and gets read from stderr/stdout.
         if (!nativeId)
             return console;
 
-        return getConsole(async (stdout, stderr) => {
+        let ret = deviceConsoles.get(nativeId);
+        if (ret)
+            return ret;
+
+        ret = getConsole(async (stdout, stderr) => {
             const connect = async () => {
                 const plugins = await getPlugins();
                 const port = await plugins.getRemoteServicePort(peer.selfName, 'console-writer');
@@ -93,19 +110,28 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             };
             connect();
         }, undefined, undefined);
+
+        deviceConsoles.set(nativeId, ret);
+        return ret;
     }
 
+    const mixinConsoles = new Map<string, Map<string, Console>>();
+
     const getMixinConsole = (mixinId: string, nativeId: ScryptedNativeId) => {
-        return getConsole(async (stdout, stderr) => {
+        let nativeIdConsoles = mixinConsoles.get(nativeId);
+        if (!nativeIdConsoles) {
+            nativeIdConsoles = new Map();
+            mixinConsoles.set(nativeId, nativeIdConsoles);
+        }
+
+        let ret = nativeIdConsoles.get(mixinId);
+        if (ret)
+            return ret;
+
+        ret = getConsole(async (stdout, stderr) => {
             if (!mixinId) {
                 return;
             }
-            // todo: fix this. a mixin provider can mixin another device to make it a mixin provider itself.
-            // so the mixin id in the mixin table will be incorrect.
-            // there's no easy way to fix this from the remote.
-            // if (!systemManager.getDeviceById(mixinId).mixins.includes(idForNativeId(nativeId))) {
-            //     return;
-            // }
             const reconnect = () => {
                 stdout.removeAllListeners();
                 stderr.removeAllListeners();
@@ -147,17 +173,40 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             }
             tryConnect();
         }, getDeviceConsole(nativeId), `[${systemManager.getDeviceById(mixinId)?.name}]`);
+
+        nativeIdConsoles.set(mixinId, ret);
+        return ret;
     }
 
-    peer.getParam('updateStats').then((updateStats: (stats: any) => void) => {
-        let lastCpuUsage: NodeJS.CpuUsage;
+    // process.cpuUsage is for the entire process.
+    // process.memoryUsage is per thread.
+    const allMemoryStats = new Map<NodeThreadWorker, NodeJS.MemoryUsage>();
+
+    peer.getParam('updateStats').then((updateStats: (stats: PluginStats) => void) => {
         setInterval(() => {
-            const cpuUsage = process.cpuUsage(lastCpuUsage);
-            lastCpuUsage = cpuUsage;
+            const cpuUsage = process.cpuUsage();
+            allMemoryStats.set(undefined, process.memoryUsage());
+
+            const memoryUsage: NodeJS.MemoryUsage = {
+                rss: 0,
+                heapTotal: 0,
+                heapUsed: 0,
+                external: 0,
+                arrayBuffers: 0,
+            }
+
+            for (const mu of allMemoryStats.values()) {
+                memoryUsage.rss += mu.rss;
+                memoryUsage.heapTotal += mu.heapTotal;
+                memoryUsage.heapUsed += mu.heapUsed;
+                memoryUsage.external += mu.external;
+                memoryUsage.arrayBuffers += mu.arrayBuffers;
+            }
+
             updateStats({
                 type: 'stats',
                 cpu: cpuUsage,
-                memoryUsage: process.memoryUsage(),
+                memoryUsage,
             });
         }, 10000);
     });
@@ -183,10 +232,6 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             api = _api;
             peer.selfName = pluginId;
         },
-        onPluginReady: async (scrypted, params, plugin) => {
-            replPort = createREPLServer(scrypted, params, plugin);
-            postInstallSourceMapSupport(scrypted);
-        },
         getPluginConsole,
         getDeviceConsole,
         getMixinConsole,
@@ -198,7 +243,59 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             }
             throw new Error(`unknown service ${name}`);
         },
-        async onLoadZip(pluginReader: PluginReader, packageJson: any) {
+        async onLoadZip(scrypted: ScryptedStatic, params: any, packageJson: any, zipData: Buffer | string, zipOptions?: PluginRemoteLoadZipOptions) {
+            let volume: any;
+            let pluginReader: PluginReader;
+            if (zipOptions?.unzippedPath && fs.existsSync(zipOptions?.unzippedPath)) {
+                volume = link(fs, ['', path.join(zipOptions.unzippedPath, 'fs')]);
+                pluginReader = name => {
+                    const filename = path.join(zipOptions.unzippedPath, name);
+                    if (!fs.existsSync(filename))
+                        return;
+                    return fs.readFileSync(filename);
+                };
+            }
+            else {
+                const admZip = new AdmZip(zipData);
+                volume = new Volume();
+                for (const entry of admZip.getEntries()) {
+                    if (entry.isDirectory)
+                        continue;
+                    if (!entry.entryName.startsWith('fs/'))
+                        continue;
+                    const name = entry.entryName.substring('fs/'.length);
+                    volume.mkdirpSync(path.dirname(name));
+                    const data = entry.getData();
+                    volume.writeFileSync(name, data);
+                }
+
+                pluginReader = name => {
+                    const entry = admZip.getEntry(name);
+                    if (!entry)
+                        return;
+                    return entry.getData();
+                }
+            }
+            zipData = undefined;
+
+            const pluginConsole = getPluginConsole?.();
+            params.console = pluginConsole;
+            params.require = (name: string) => {
+                if (name === 'fakefs' || (name === 'fs' && !packageJson.scrypted.realfs)) {
+                    return volume;
+                }
+                if (name === 'realfs') {
+                    return require('fs');
+                }
+                const module = require(name);
+                return module;
+            };
+            const window: any = {};
+            const exports: any = window;
+            window.exports = exports;
+            params.window = window;
+            params.exports = exports;
+
             const entry = pluginReader('main.nodejs.js.map')
             const map = entry?.toString();
 
@@ -234,10 +331,101 @@ export function startPluginRemote(pluginId: string, peerSend: (message: RpcMessa
             };
 
             await installOptionalDependencies(getPluginConsole(), packageJson);
+
+            const main = pluginReader('main.nodejs.js');
+            pluginReader = undefined;
+            const script = main.toString();
+
+
+            const forks = new Set<PluginRemote>();
+
+            scrypted.fork = () => {
+                const ntw = new NodeThreadWorker(pluginId, {
+                    env: process.env,
+                    pluginDebug: undefined,
+                });
+
+                const result = (async () => {
+                    const threadPeer = new RpcPeer('main', 'thread', (message, reject) => ntw.send(message, reject));
+                    threadPeer.params.updateStats = (stats: PluginStats) => {
+                        allMemoryStats.set(ntw, stats.memoryUsage);
+                    }
+                    ntw.setupRpcPeer(threadPeer);
+
+                    class PluginForkAPI extends PluginAPIProxy {
+                        [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = (api as any)[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS];
+
+                        setStorage(nativeId: string, storage: { [key: string]: any; }): Promise<void> {
+                            const id = deviceManager.nativeIds.get(nativeId).id;
+                            (scrypted.pluginRemoteAPI as PluginRemote).setNativeId(nativeId, id, storage);
+                            for (const r of forks) {
+                                if (r === remote)
+                                    continue;
+                                r.setNativeId(nativeId, id, storage);
+                            }
+                            return super.setStorage(nativeId, storage);
+                        }
+                    }
+                    const forkApi = new PluginForkAPI(api);
+
+                    const remote = await setupPluginRemote(threadPeer, forkApi, pluginId, () => systemManager.getSystemState());
+                    forks.add(remote);
+                    ntw.worker.on('exit', () => {
+                        forkApi.removeListeners();
+                        forks.delete(remote);
+                        allMemoryStats.delete(ntw);
+                    });
+
+                    for (const [nativeId, dmd] of deviceManager.nativeIds.entries()) {
+                        await remote.setNativeId(nativeId, dmd.id, dmd.storage);
+                    }
+
+                    const forkOptions = Object.assign({}, zipOptions);
+                    forkOptions.fork = true;
+                    return remote.loadZip(packageJson, zipData, forkOptions)
+                })();
+
+                result.catch(() => ntw.kill());
+
+                return {
+                    worker: ntw.worker,
+                    result,
+                }
+            }
+
+            try {
+                peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
+
+                if (zipOptions?.fork) {
+                    pluginConsole?.log('plugin forked');
+                    const fork = exports.fork;
+                    const forked = await fork();
+                    forked[RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION] = true;
+                    return forked;
+                }
+
+                pluginConsole?.log('plugin loaded');
+                let pluginInstance = exports.default;
+                // support exporting a plugin class, plugin main function,
+                // or a plugin instance
+                if (pluginInstance.toString().startsWith('class '))
+                    pluginInstance = new pluginInstance();
+                if (typeof pluginInstance === 'function')
+                    pluginInstance = await pluginInstance();
+
+                replPort = createREPLServer(scrypted, params, pluginInstance);
+                postInstallSourceMapSupport(scrypted);
+
+                return pluginInstance;
+            }
+            catch (e) {
+                pluginConsole?.error('plugin failed to start', e);
+                throw e;
+            }
         }
     }).then(scrypted => {
         systemManager = scrypted.systemManager;
-        deviceManager = scrypted.deviceManager;
+        deviceManager = scrypted.deviceManager as DeviceManagerImpl;
     });
 
     return peer;

package/src/plugin/plugin-remote.ts

@@ -1,15 +1,10 @@
-import AdmZip from 'adm-zip';
-import { Volume } from 'memfs';
-import path from 'path';
-import { ScryptedNativeId, DeviceManager, Logger, Device, DeviceManifest, DeviceState, EndpointManager, SystemDeviceState, ScryptedStatic, SystemManager, MediaManager, ScryptedMimeTypes, ScryptedInterface, ScryptedInterfaceProperty, HttpRequest } from '@scrypted/types'
-import { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
-import { SystemManagerImpl } from './system';
+import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointManager, HttpRequest, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
+import { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { createWebSocketClass, WebSocketConnectCallbacks, WebSocketMethods } from './plugin-remote-websocket';
-import fs from 'fs';
 import { checkProperty } from './plugin-state-check';
-const { link } = require('linkfs');
+import { SystemManagerImpl } from './system';
 
 class DeviceLogger implements Logger {
     nativeId: ScryptedNativeId;
@@ -112,6 +107,10 @@ class DeviceStateProxyHandler implements ProxyHandler<any> {
     get?(target: any, p: PropertyKey, receiver: any) {
         if (p === 'id')
             return this.id;
+        if (p === RpcPeer.PROPERTY_PROXY_PROPERTIES)
+            return { id: this.id }
+        if (p === 'setState')
+            return this.setState;
         return this.deviceManager.systemManager.state[this.id][p as string]?.value;
     }
 
@@ -133,7 +132,7 @@ interface DeviceManagerDevice {
     storage: { [key: string]: any };
 }
 
-class DeviceManagerImpl implements DeviceManager {
+export class DeviceManagerImpl implements DeviceManager {
     api: PluginAPI;
     nativeIds = new Map<string, DeviceManagerDevice>();
     deviceStorage = new Map<string, StorageImpl>();
@@ -158,6 +157,11 @@ class DeviceManagerImpl implements DeviceManager {
         return new Proxy(handler, handler);
     }
 
+    createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>): DeviceState {
+        const handler = new DeviceStateProxyHandler(this, id, setState);
+        return new Proxy(handler, handler);
+    }
+
     getDeviceStorage(nativeId?: any): StorageImpl {
         let ret = this.deviceStorage.get(nativeId);
         if (!ret) {
@@ -302,7 +306,7 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
         if (!peer.constructorSerializerMap.get(Buffer))
             peer.addSerializer(Buffer, 'Buffer', new BufferSerializer());
         const getRemote = await peer.getParam('getRemote');
-        const remote = await getRemote(api, pluginId);
+        const remote = await getRemote(api, pluginId) as PluginRemote;
 
         await remote.setSystemState(getSystemState());
         api.listen((id, eventDetails, eventData) => {
@@ -342,18 +346,17 @@ export interface WebSocketCustomHandler {
 export type PluginReader = (name: string) => Buffer;
 
 export interface PluginRemoteAttachOptions {
-    createMediaManager?: (systemManager: SystemManager, deviceManager: DeviceManager) => Promise<MediaManager>;
+    createMediaManager?: (systemManager: SystemManager, deviceManager: DeviceManagerImpl) => Promise<MediaManager>;
     getServicePort?: (name: string, ...args: any[]) => Promise<number>;
     getDeviceConsole?: (nativeId?: ScryptedNativeId) => Console;
     getPluginConsole?: () => Console;
     getMixinConsole?: (id: string, nativeId?: ScryptedNativeId) => Console;
-    onLoadZip?: (pluginReader: PluginReader, packageJson: any) => Promise<void>;
+    onLoadZip?: (scrypted: ScryptedStatic, params: any, packageJson: any, zipData: Buffer | string, zipOptions?: PluginRemoteLoadZipOptions) => Promise<any>;
     onGetRemote?: (api: PluginAPI, pluginId: string) => Promise<void>;
-    onPluginReady?: (scrypted: ScryptedStatic, params: any, plugin: any) => Promise<void>;
 }
 
 export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOptions): Promise<ScryptedStatic> {
-    const { createMediaManager, getServicePort, getDeviceConsole, getMixinConsole, getPluginConsole } = options || {};
+    const { createMediaManager, getServicePort, getDeviceConsole, getMixinConsole } = options || {};
 
     if (!peer.constructorSerializerMap.get(Buffer))
         peer.addSerializer(Buffer, 'Buffer', new BufferSerializer());
@@ -367,7 +370,11 @@ 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, deviceManager);
+        const hostMediaManager = await api.getMediaManager();
+        if (!hostMediaManager) {
+            peer.params['createMediaManager'] = async () => createMediaManager(systemManager, deviceManager);
+        }
+        const mediaManager = hostMediaManager || await createMediaManager(systemManager, deviceManager);
         peer.params['mediaManager'] = mediaManager;
         const ioSockets: { [id: string]: WebSocketConnectCallbacks } = {};
 
@@ -382,6 +389,8 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             endpointManager,
             mediaManager,
             log,
+            pluginHostAPI: api,
+            pluginRemoteAPI: undefined,
         }
 
         delete peer.params.getRemote;
@@ -403,9 +412,8 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                 'setNativeId',
             ],
             getServicePort,
-            createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>) {
-                const handler = new DeviceStateProxyHandler(deviceManager, id, setState);
-                return new Proxy(handler, handler);
+            async createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>) {
+                return deviceManager.createDeviceState(id, setState);
             },
 
             async ioEvent(id: string, event: string, message?: any) {
@@ -472,50 +480,6 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             },
 
             async loadZip(packageJson: any, zipData: Buffer | string, zipOptions?: PluginRemoteLoadZipOptions) {
-                const pluginConsole = getPluginConsole?.();
-
-                let volume: any;
-                let pluginReader: PluginReader;
-                if (zipOptions?.unzippedPath && fs.existsSync(zipOptions?.unzippedPath)) {
-                    volume = link(fs, ['', path.join(zipOptions.unzippedPath, 'fs')]);
-                    pluginReader = name => {
-                        const filename = path.join(zipOptions.unzippedPath, name);
-                        if (!fs.existsSync(filename))
-                            return;
-                        return fs.readFileSync(filename);
-                    };
-                }
-                else {
-                    const admZip = new AdmZip(zipData);
-                    volume = new Volume();
-                    for (const entry of admZip.getEntries()) {
-                        if (entry.isDirectory)
-                            continue;
-                        if (!entry.entryName.startsWith('fs/'))
-                            continue;
-                        const name = entry.entryName.substring('fs/'.length);
-                        volume.mkdirpSync(path.dirname(name));
-                        const data = entry.getData();
-                        volume.writeFileSync(name, data);
-                    }
-
-                    pluginReader = name => {
-                        const entry = admZip.getEntry(name);
-                        if (!entry)
-                            return;
-                        return entry.getData();
-                    }
-                }
-                zipData = undefined;
-
-                await options?.onLoadZip?.(pluginReader, packageJson);
-                const main = pluginReader('main.nodejs.js');
-                pluginReader = undefined;
-                const script = main.toString();
-                const window: any = {};
-                const exports: any = window;
-                window.exports = exports;
-
 
                 function websocketConnect(url: string, protocols: any, callbacks: WebSocketConnectCallbacks) {
                     if (url.startsWith('io://') || url.startsWith('ws://')) {
@@ -535,18 +499,6 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
 
                 const params: any = {
                     __filename: undefined,
-                    exports,
-                    window,
-                    require: (name: string) => {
-                        if (name === 'fakefs' || (name === 'fs' && !packageJson.scrypted.realfs)) {
-                            return volume;
-                        }
-                        if (name === 'realfs') {
-                            return require('fs');
-                        }
-                        const module = require(name);
-                        return module;
-                    },
                     deviceManager,
                     systemManager,
                     mediaManager,
@@ -555,32 +507,17 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                     localStorage,
                     pluginHostAPI: api,
                     WebSocket: createWebSocketClass(websocketConnect),
+                    pluginRuntimeAPI: ret,
                 };
 
-                params.console = pluginConsole;
+                params.pluginRuntimeAPI = ret;
 
-                try {
-                    peer.evalLocal(script, zipOptions?.filename || '/plugin/main.nodejs.js', params);
-                    pluginConsole?.log('plugin successfully loaded');
-
-                    let pluginInstance = exports.default;
-                    // support exporting a plugin class, plugin main function,
-                    // or a plugin instance
-                    if (pluginInstance.toString().startsWith('class '))
-                        pluginInstance = new pluginInstance();
-                    if (typeof pluginInstance === 'function')
-                        pluginInstance = await pluginInstance();
-
-                    await options?.onPluginReady?.(ret, params, pluginInstance);
-                    return pluginInstance;
-                }
-                catch (e) {
-                    pluginConsole?.error('plugin failed to start', e);
-                    throw e;
-                }
+                return options.onLoadZip(ret, params, packageJson, zipData, zipOptions);
             },
         }
 
+        ret.pluginRemoteAPI = remote;
+
         return remote;
     }