@scrypted/server 0.0.88 → 0.0.92

package/src/plugin/plugin-console.ts

@@ -4,40 +4,67 @@ import { listenZero } from './listen-zero';
 import { Server } from 'net';
 import { once } from 'events';
 import net from 'net'
-import { Readable } from 'stream';
+import { Readable, PassThrough } from 'stream';
+import { Console } from 'console';
 
 export interface ConsoleServer {
+    pluginConsole: Console;
     readPort: number,
     writePort: number,
     readServer: net.Server,
     writeServer: net.Server,
     sockets: Set<net.Socket>;
 }
-export async function createConsoleServer(stdout: Readable, stderr: Readable) {
-    const outputs = new Map<string, Buffer[]>();
-    const appendOutput = (data: Buffer, nativeId: ScryptedNativeId) => {
+
+export interface StdPassThroughs {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    buffers: Buffer[];
+}
+
+export async function createConsoleServer(remoteStdout: Readable, remoteStderr: Readable) {
+    const outputs = new Map<string, StdPassThroughs>();
+
+    const getPassthroughs = (nativeId?: ScryptedNativeId) => {
         if (!nativeId)
             nativeId = undefined;
-        let buffers = outputs.get(nativeId);
-        if (!buffers) {
-            buffers = [];
-            outputs.set(nativeId, buffers);
+        let pts = outputs.get(nativeId)
+        if (!pts) {
+            const stdout = new PassThrough();
+            const stderr = new PassThrough();
+
+            pts = {
+                stdout,
+                stderr,
+                buffers: [],
+            }
+            outputs.set(nativeId, pts);
+
+            const appendOutput = (data: Buffer) => {
+                const { buffers } = pts;
+                buffers.push(data);
+                // when we're over 4000 lines or whatever these buffer are,
+                // truncate down to 2000.
+                if (buffers.length > 4000)
+                    pts.buffers = buffers.slice(buffers.length - 2000);
+            };
+
+            stdout.on('data', appendOutput);
+            stderr.on('data', appendOutput);
         }
-        buffers.push(data);
-        // when we're over 4000 lines or whatever these buffer are,
-        // truncate down to 2000.
-        if (buffers.length > 4000)
-            outputs.set(nativeId, buffers.slice(buffers.length - 2000))
-    };
 
-    const sockets = new Set<net.Socket>();
+        return pts;
+    }
 
-    const events = new EventEmitter();
-    events.on('stdout', appendOutput);
-    events.on('stderr', appendOutput);
+    let pluginConsole: Console;
+    {
+        const { stdout, stderr } = getPassthroughs();
+        remoteStdout.pipe(stdout);
+        remoteStderr.pipe(stderr);
+        pluginConsole = new Console(stdout, stderr);
+    }
 
-    stdout.on('data', data => events.emit('stdout', data));
-    stderr.on('data', data => events.emit('stderr', data));
+    const sockets = new Set<net.Socket>();
 
     const readServer = new Server(async (socket) => {
         sockets.add(socket);
@@ -47,24 +74,22 @@ export async function createConsoleServer(stdout: Readable, stderr: Readable) {
         if (filter === 'undefined')
             filter = undefined;
 
-        const buffers = outputs.get(filter);
+        const pts = outputs.get(filter);
+        const buffers = pts?.buffers;
         if (buffers) {
             const concat = Buffer.concat(buffers);
-            outputs.set(filter, [concat]);
+            pts.buffers = [concat];
             socket.write(concat);
         }
 
-        const cb = (data: Buffer, nativeId: ScryptedNativeId) => {
-            if (nativeId !== filter)
-                return;
-            socket.write(data);
-        };
-        events.on('stdout', cb)
-        events.on('stderr', cb)
+        const cb = (data: Buffer) => socket.write(data);
+        const { stdout, stderr } = getPassthroughs(filter);
+        stdout.on('data', cb);
+        stderr.on('data', cb);
 
         const cleanup = () => {
-            events.removeListener('stdout', cb);
-            events.removeListener('stderr', cb);
+            stdout.removeListener('data', cb);
+            stderr.removeListener('data', cb);
             socket.destroy();
             socket.removeAllListeners();
             sockets.delete(socket);
@@ -88,9 +113,8 @@ export async function createConsoleServer(stdout: Readable, stderr: Readable) {
         if (filter === 'undefined')
             filter = undefined;
 
-        const cb = (data: Buffer) => events.emit('stdout', data, filter);
-
-        socket.on('data', cb);
+        const { stdout } = getPassthroughs(filter);
+        socket.pipe(stdout, { end: false });
 
         const cleanup = () => {
             socket.destroy();
@@ -106,6 +130,7 @@ export async function createConsoleServer(stdout: Readable, stderr: Readable) {
     const writePort = await listenZero(writeServer);
 
     return {
+        pluginConsole,
         readPort,
         writePort,
         readServer,

package/src/plugin/plugin-device.ts

@@ -9,114 +9,220 @@ import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from
 
 interface MixinTable {
     mixinProviderId: string;
-    interfaces: string[];
-    proxy: Promise<any>;
+    entry: Promise<MixinTableEntry>;
+}
+
+interface MixinTableEntry {
+    interfaces: Set<string>
+    allInterfaces: string[];
+    proxy: any;
+    error?: Error;
 }
 
 export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevice {
     scrypted: ScryptedRuntime;
     id: string;
-    mixinTable: Promise<MixinTable[]>;
+    mixinTable: MixinTable[];
 
     constructor(scrypted: ScryptedRuntime, id: string) {
         this.scrypted = scrypted;
         this.id = id;
     }
 
+    invalidateEntry(mixinEntry: MixinTable) {
+        if (!mixinEntry.mixinProviderId)
+            return;
+        (async () => {
+            const mixinProvider = this.scrypted.getDevice(mixinEntry.mixinProviderId) as ScryptedDevice & MixinProvider;
+            const { proxy } = await mixinEntry.entry;
+            mixinProvider?.releaseMixin(this.id, proxy);
+        })().catch(() => { });
+    }
+
     // should this be async?
     invalidate() {
         const mixinTable = this.mixinTable;
         this.mixinTable = undefined;
-        (async () => {
-            for (const mixinEntry of (await mixinTable || [])) {
-                if (!mixinEntry.mixinProviderId)
-                    continue;
-                (async () => {
-                    const mixinProvider = this.scrypted.getDevice(mixinEntry.mixinProviderId) as ScryptedDevice & MixinProvider;
-                    mixinProvider?.releaseMixin(this.id, await mixinEntry.proxy);
-                })().catch(() => { });
-            }
-        })().catch(() => { });;
+        for (const mixinEntry of (mixinTable || [])) {
+            this.invalidateEntry(mixinEntry);
+        }
     }
 
-    // this must not be async, because it potentially changes execution order.
-    ensureProxy(): Promise<PluginDevice> {
+    invalidateMixinTable() {
+        if (!this.mixinTable)
+            return this.invalidate();
+
+        let previousMixinIds = this.mixinTable?.map(entry => entry.mixinProviderId) || [];
+        previousMixinIds.pop();
+        previousMixinIds = previousMixinIds.reverse();
+
         const pluginDevice = this.scrypted.findPluginDeviceById(this.id);
         if (!pluginDevice)
-            throw new Error(`device ${this.id} does not exist`);
+            return this.invalidate();
+
+        const mixins = getState(pluginDevice, ScryptedInterfaceProperty.mixins) || [];
+        // iterate the new mixin table to find the last good mixin,
+        // and resume creation from there.
+        let lastValidMixinId: string;
+        for (const mixinId of mixins) {
+            if (!previousMixinIds.length) {
+                // reached of the previous mixin table, meaning
+                // mixins were added.
+                break;
+            }
+            const check = previousMixinIds.shift();
+            if (check !== mixinId)
+                break;
 
-        if (this.mixinTable)
-            return Promise.resolve(pluginDevice);
+            lastValidMixinId = mixinId;
+        }
 
-        this.mixinTable = (async () => {
-            let proxy: any;
-            if (!pluginDevice.nativeId) {
-                const plugin = this.scrypted.plugins[pluginDevice.pluginId];
-                proxy = await plugin.module;
-            }
-            else {
-                const providerId = getState(pluginDevice, ScryptedInterfaceProperty.providerId);
-                const provider = this.scrypted.getDevice(providerId) as ScryptedDevice & DeviceProvider;
-                proxy = await provider.getDevice(pluginDevice.nativeId);
-            }
+        if (!lastValidMixinId)
+            return this.invalidate();
 
-            if (!proxy)
-                console.error('null proxy', this.id);
-            // after creating an actual device, apply all the mixins
-            const type = getDisplayType(pluginDevice);
-            const allInterfaces: ScryptedInterface[] = getState(pluginDevice, ScryptedInterfaceProperty.providedInterfaces) || [];
+        // invalidate and remove everything up to lastValidMixinId
+        while (true) {
+            const entry = this.mixinTable[0];
+            if (entry.mixinProviderId === lastValidMixinId)
+                break;
+            this.mixinTable.shift();
+            this.invalidateEntry(entry);
+        }
 
-            const mixinTable: MixinTable[] = [];
-            mixinTable.unshift({
-                mixinProviderId: undefined,
-                interfaces: allInterfaces.slice(),
-                proxy,
-            })
+        this.ensureProxy(lastValidMixinId);
+    }
 
-            for (const mixinId of getState(pluginDevice, ScryptedInterfaceProperty.mixins) || []) {
-                const mixinProvider = this.scrypted.getDevice(mixinId) as ScryptedDevice & MixinProvider;
+    // this must not be async, because it potentially changes execution order.
+    ensureProxy(lastValidMixinId?: string): Promise<PluginDevice> {
+        const pluginDevice = this.scrypted.findPluginDeviceById(this.id);
+        if (!pluginDevice)
+            throw new Error(`device ${this.id} does not exist`);
+
+        let previousEntry: Promise<MixinTableEntry>;
+        if (!lastValidMixinId) {
+            if (this.mixinTable)
+                return Promise.resolve(pluginDevice);
+
+            this.mixinTable = [];
 
+            previousEntry = (async () => {
+                let proxy;
                 try {
-                    const interfaces = await mixinProvider?.canMixin(type, allInterfaces) as any as ScryptedInterface[];
-                    if (!interfaces) {
-                        console.warn(`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);
-                        continue;
+                    if (!pluginDevice.nativeId) {
+                        const plugin = this.scrypted.plugins[pluginDevice.pluginId];
+                        proxy = await plugin.module;
+                    }
+                    else {
+                        const providerId = getState(pluginDevice, ScryptedInterfaceProperty.providerId);
+                        const provider = this.scrypted.getDevice(providerId) as ScryptedDevice & DeviceProvider;
+                        proxy = await provider.getDevice(pluginDevice.nativeId);
                     }
 
-                    const wrappedHandler = new PluginDeviceProxyHandler(this.scrypted, this.id);
-                    wrappedHandler.mixinTable = Promise.resolve(mixinTable.slice());
-                    const wrappedProxy = new Proxy(wrappedHandler, wrappedHandler);
-
-                    const host = this.scrypted.getPluginHostForDeviceId(mixinId);
-                    const deviceState = await host.remote.createDeviceState(this.id,
-                        async (property, value) => this.scrypted.stateManager.setPluginDeviceState(pluginDevice, property, value));
-                    const mixinProxy = await mixinProvider.getMixin(wrappedProxy, allInterfaces, deviceState);
-                    if (!mixinProxy)
-                        throw new Error(`mixin provider ${mixinId} did not return mixin for ${this.id}`);
-                    allInterfaces.push(...interfaces);
-                    proxy = mixinProxy;
-
-                    mixinTable.unshift({
-                        mixinProviderId: mixinId,
-                        interfaces,
-                        proxy,
-                    })
+                    if (!proxy)
+                        console.warn('no device was returned by the plugin', this.id);
                 }
                 catch (e) {
-                    console.warn("mixin provider failure", mixinId, e);
+                    console.warn('error occured retrieving device from plugin');
                 }
-            }
 
-            const mixinInterfaces = [...new Set(allInterfaces)].sort();
-            this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.interfaces, mixinInterfaces);
+                const interfaces: ScryptedInterface[] = getState(pluginDevice, ScryptedInterfaceProperty.providedInterfaces) || [];
+                return {
+                    proxy,
+                    interfaces: new Set<string>(interfaces),
+                    allInterfaces: interfaces,
+                }
+            })();
+
+            this.mixinTable.unshift({
+                mixinProviderId: undefined,
+                entry: previousEntry,
+            });
+        }
+        else {
+            if (!this.mixinTable)
+                throw new Error('mixin table partial invalidation was called with empty mixin table');
+            const prevTable = this.mixinTable.find(table => table.mixinProviderId === lastValidMixinId);
+            if (!prevTable)
+                throw new Error('mixin table partial invalidation was called with invalid lastValidMixinId');
+            previousEntry = prevTable.entry;
+        }
+
+        const type = getDisplayType(pluginDevice);
+
+        for (const mixinId of getState(pluginDevice, ScryptedInterfaceProperty.mixins) || []) {
+            if (lastValidMixinId) {
+                if (mixinId === lastValidMixinId)
+                    lastValidMixinId = undefined;
+                continue;
+            }
 
-            return mixinTable;
-        })();
+            const wrappedMixinTable = this.mixinTable.slice();
+
+            this.mixinTable.unshift({
+                mixinProviderId: mixinId,
+                entry: (async () => {
+                    let { allInterfaces } = await previousEntry;
+                    try {
+                        const mixinProvider = this.scrypted.getDevice(mixinId) as ScryptedDevice & MixinProvider;
+                        const interfaces = 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);
+                            return {
+                                allInterfaces,
+                                interfaces: new Set<string>(),
+                                proxy: undefined as any,
+                            };
+                        }
+
+                        allInterfaces = allInterfaces.slice();
+                        allInterfaces.push(...interfaces);
+                        const combinedInterfaces = [...new Set(allInterfaces)];
+
+                        const wrappedHandler = new PluginDeviceProxyHandler(this.scrypted, this.id);
+                        wrappedHandler.mixinTable = wrappedMixinTable;
+                        const wrappedProxy = new Proxy(wrappedHandler, wrappedHandler);
+
+                        const host = this.scrypted.getPluginHostForDeviceId(mixinId);
+                        const deviceState = await host.remote.createDeviceState(this.id,
+                            async (property, value) => this.scrypted.stateManager.setPluginDeviceState(pluginDevice, property, value));
+                        const mixinProxy = await mixinProvider.getMixin(wrappedProxy, allInterfaces as ScryptedInterface[], deviceState);
+                        if (!mixinProxy)
+                            throw new Error(`mixin provider ${mixinId} did not return mixin for ${this.id}`);
+
+                        return {
+                            interfaces: new Set<string>(interfaces),
+                            allInterfaces: combinedInterfaces,
+                            proxy: mixinProxy,
+                        };
+                    }
+                    catch (e) {
+                        // on any error, do not advertise interfaces
+                        // on this mixin, so as to prevent total failure?
+                        // this has been the behavior for a while,
+                        // but maybe interfaces implemented by that mixin
+                        // should rethrow the error caught here in applyMixin.
+                        console.warn(e);
+                        return {
+                            allInterfaces,
+                            interfaces: new Set<string>(),
+                            error: e,
+                            proxy: undefined as any,
+                        };
+                    }
+                })(),
+            });
+        }
 
-        return this.mixinTable.then(_ => pluginDevice);
+        return this.mixinTable[0].entry.then(entry => {
+            this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.interfaces, entry.allInterfaces);
+            return pluginDevice;
+        });
     }
 
     get(target: any, p: PropertyKey, receiver: any): any {
@@ -180,12 +286,14 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
         if (!iface)
             throw new Error(`unknown method ${method}`);
 
-        const mixinTable = await this.mixinTable;
-        for (const mixin of mixinTable) {
-
+        for (const mixin of this.mixinTable) {
+            const { interfaces, proxy } = await mixin.entry;
             // this could be null?
-            if (mixin.interfaces.includes(iface))
-                return (await mixin.proxy)[method](...argArray);
+            if (interfaces.has(iface)) {
+                if (!proxy)
+                    throw new Error(`device is unavailable ${this.id} (mixin ${mixin.mixinProviderId})`);
+                return proxy[method](...argArray);
+            }
         }
 
         throw new Error(`${method} not implemented`)

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

@@ -47,8 +47,9 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         const mixins: string[] = getState(device, ScryptedInterfaceProperty.mixins) || [];
         if (!mixins.includes(mixinProvider._id))
             throw new Error(`${mixinProvider._id} is not a mixin provider for ${id}`);
-        const tableEntry = (await this.scrypted.devices[device._id].handler.mixinTable).find(entry => entry.mixinProviderId === mixinProvider._id);
-        if (!tableEntry.interfaces.includes(eventInterface))
+        const tableEntry = this.scrypted.devices[device._id].handler.mixinTable.find(entry => entry.mixinProviderId === mixinProvider._id);
+        const { interfaces } = await tableEntry.entry;
+        if (!interfaces.has(eventInterface))
             throw new Error(`${mixinProvider._id} does not mixin ${eventInterface} for ${id}`);
         this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
     }

package/src/plugin/plugin-host.ts

@@ -117,7 +117,6 @@ export class PluginHost {
                 } = (socket.request as any).scrypted;
 
                 const handler = this.scrypted.getDevice<EngineIOHandler>(pluginDevice._id);
-                handler.onConnection(endpointRequest, `io://${socket.id}`);
 
                 socket.on('message', message => {
                     this.remote.ioEvent(socket.id, 'message', message)
@@ -125,6 +124,8 @@ export class PluginHost {
                 socket.on('close', reason => {
                     this.remote.ioEvent(socket.id, 'close');
                 });
+
+                await handler.onConnection(endpointRequest, `io://${socket.id}`);
             }
             catch (e) {
                 console.error('engine.io plugin error', e);
@@ -297,6 +298,11 @@ export class PluginHost {
         this.worker.stderr.on('data', data => console.error(data.toString()));
         this.consoleServer = createConsoleServer(this.worker.stdout, this.worker.stderr);
 
+        this.consoleServer.then(cs => {
+            const { pluginConsole } = cs;
+            pluginConsole.log('starting plugin', this.pluginId, this.packageJson.version);
+        });
+
         this.worker.on('disconnect', () => {
             connected = false;
             logger.log('e', `${this.pluginName} disconnected`);
@@ -384,6 +390,11 @@ export function startPluginRemote() {
     }
 
     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) => {
             const plugins = await api.getComponent('plugins');
             const connect = async () => {
@@ -459,9 +470,9 @@ export function startPluginRemote() {
 
     let _pluginConsole: Console;
     const getPluginConsole = () => {
-        if (_pluginConsole)
-            return _pluginConsole;
-        _pluginConsole = getDeviceConsole(undefined);
+        if (!_pluginConsole)
+            _pluginConsole = getDeviceConsole(undefined);
+        return _pluginConsole;
     }
 
     attachPluginRemote(peer, {
@@ -474,7 +485,7 @@ export function startPluginRemote() {
             pluginId = _pluginId;
             peer.selfName = pluginId;
         },
-        onPluginReady: async(scrypted, params, plugin) => {
+        onPluginReady: async (scrypted, params, plugin) => {
             replPort = createREPLServer(scrypted, params, plugin);
         },
         getPluginConsole,

package/src/plugin/plugin-remote.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import { ScryptedNativeId, DeviceManager, Logger, Device, DeviceManifest, DeviceState, EndpointManager, SystemDeviceState, ScryptedStatic, SystemManager, MediaManager, ScryptedMimeTypes, ScryptedInterface, ScryptedInterfaceProperty, HttpRequest } from '@scrypted/sdk/types'
 import { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { SystemManagerImpl } from './system';
-import { RpcPeer, RPCResultError, PROPERTY_PROXY_ONEWAY_METHODS, PROPERTY_JSON_DISABLE_SERIALIZATION  } from '../rpc';
+import { RpcPeer, RPCResultError, PROPERTY_PROXY_ONEWAY_METHODS, PROPERTY_JSON_DISABLE_SERIALIZATION } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
 import { EventEmitter } from 'events';
 import { createWebSocketClass } from './plugin-remote-websocket';
@@ -407,7 +407,6 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
 
             async loadZip(packageJson: any, zipData: Buffer, zipOptions?: PluginRemoteLoadZipOptions) {
                 const pluginConsole = getPluginConsole?.();
-                pluginConsole?.log('starting plugin', pluginId, packageJson.version);
                 const zip = new AdmZip(zipData);
                 await options?.onLoadZip?.(zip, packageJson);
                 const main = zip.getEntry('main.nodejs.js');

package/src/plugin/plugin-repl.ts

@@ -41,7 +41,7 @@ export async function createREPLServer(scrypted: ScryptedStatic, params: any, pl
         delete ctx.WebSocket;
         delete ctx.pluginHostAPI;
 
-        const replFilter = new Set<string>(['require', 'localStorage'])
+        const replFilter = new Set<string>(['require', 'localStorage', 'exports', '__filename'])
         const replVariables = Object.keys(ctx).filter(key => !replFilter.has(key));
 
         const welcome = `JavaScript REPL variables:\n${replVariables.map(key => '  ' + key).join('\n')}\n\n`;

package/src/plugin/plugin-volume.ts

@@ -1,9 +1,14 @@
 import path from 'path';
 import mkdirp from 'mkdirp';
 
-export function ensurePluginVolume(pluginId: string) {
+export function getPluginVolume(pluginId: string) {
     const volume = path.join(process.cwd(), 'volume');
     const pluginVolume = path.join(volume, 'plugins', pluginId);
+    return pluginVolume;
+}
+
+export function ensurePluginVolume(pluginId: string) {
+    const pluginVolume = getPluginVolume(pluginId);
     try {
         mkdirp.sync(pluginVolume);
     }

package/src/runtime.ts

@@ -28,6 +28,8 @@ import { Alerts } from './services/alerts';
 import { Info } from './services/info';
 import io from 'engine.io';
 import {spawn as ptySpawn} from 'node-pty';
+import rimraf from 'rimraf';
+import { getPluginVolume } from './plugin/plugin-volume';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -317,7 +319,7 @@ export class ScryptedRuntime {
         }
 
         if (!isEngineIOEndpoint && isUpgrade) {
-            this.wss.handleUpgrade(req, req.socket, (req as any).upgradeHead, ws => {
+            this.wss.handleUpgrade(req, req.socket, (req as any).upgradeHead, async (ws) => {
                 try {
                     const handler = this.getDevice<EngineIOHandler>(pluginDevice._id);
                     const id = 'ws-' + this.wsAtomic++;
@@ -328,8 +330,6 @@ export class ScryptedRuntime {
                     }
                     pluginHost.ws[id] = ws;
 
-                    handler.onConnection(httpRequest, `ws://${id}`);
-
                     ws.on('message', async (message) => {
                         try {
                             pluginHost.remote.ioEvent(id, 'message', message)
@@ -346,6 +346,8 @@ export class ScryptedRuntime {
                         }
                         delete pluginHost.ws[id];
                     });
+
+                    await handler.onConnection(httpRequest, `ws://${id}`);
                 }
                 catch (e) {
                     console.error('websocket plugin error', e);
@@ -424,6 +426,15 @@ export class ScryptedRuntime {
         return proxyPair;
     }
 
+    // should this be async?
+    invalidatePluginDeviceMixins(id: string) {
+        const proxyPair = this.devices[id];
+        if (!proxyPair)
+            return;
+        proxyPair.handler.invalidateMixinTable();
+        return proxyPair;
+    }
+
     async installNpm(pkg: string, version?: string): Promise<PluginHost> {
         const registry = (await axios(`https://registry.npmjs.org/${pkg}`)).data;
         if (!version) {
@@ -573,6 +584,7 @@ export class ScryptedRuntime {
             const plugin = await this.datastore.tryGet(Plugin, device.pluginId);
             this.killPlugin(plugin);
             await this.datastore.remove(plugin);
+            rimraf.sync(getPluginVolume(plugin._id));
         }
         this.stateManager.removeDevice(device._id);
 

package/src/services/plugin.ts

@@ -29,7 +29,7 @@ export class PluginComponent {
         const pluginDevice = this.scrypted.findPluginDeviceById(id);
         this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.mixins, [...new Set(mixins)] || []);
         await this.scrypted.datastore.upsert(pluginDevice);
-        const device = this.scrypted.invalidatePluginDevice(id);
+        const device = this.scrypted.invalidatePluginDeviceMixins(id);
         await device?.handler.ensureProxy();
     }
     async getMixins(id: string) {