@scrypted/server 0.1.14 → 0.2.1

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,16 +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';
-import _ from 'lodash';
-const { link } = require('linkfs');
+import { SystemManagerImpl } from './system';
 
 class DeviceLogger implements Logger {
     nativeId: ScryptedNativeId;
@@ -113,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;
     }
 
@@ -134,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>();
@@ -159,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) {
@@ -303,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) => {
@@ -343,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());
@@ -368,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 } = {};
 
@@ -383,6 +389,8 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             endpointManager,
             mediaManager,
             log,
+            pluginHostAPI: api,
+            pluginRemoteAPI: undefined,
         }
 
         delete peer.params.getRemote;
@@ -404,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) {
@@ -473,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://')) {
@@ -536,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,
@@ -556,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;
     }
 

package/src/plugin/runtime/node-fork-worker.ts

@@ -4,6 +4,8 @@ import path from 'path';
 import { RpcMessage, RpcPeer } from "../../rpc";
 import { ChildProcessWorker } from "./child-process-worker";
 import { getPluginNodePath } from "../plugin-npm-dependencies";
+import { SidebandSocketSerializer } from "../socket-serializer";
+import net from "net";
 
 export class NodeForkWorker extends ChildProcessWorker {
 
@@ -31,7 +33,12 @@ export class NodeForkWorker extends ChildProcessWorker {
 
     setupRpcPeer(peer: RpcPeer): void {
         this.worker.on('message', (message, sendHandle) => {
-            if (sendHandle) {
+            if ((message as any).type && sendHandle) {
+                peer.handleMessage(message as any, {
+                    sendHandle,
+                });
+            }
+            else if (sendHandle) {
                 this.emit('rpc', message, sendHandle);
             }
             else {
@@ -39,13 +46,14 @@ export class NodeForkWorker extends ChildProcessWorker {
             }
         });
         peer.transportSafeArgumentTypes.add(Buffer.name);
+        peer.addSerializer(net.Socket, net.Socket.name, new SidebandSocketSerializer());
     }
 
-    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.send(message, undefined, e => {
+            this.worker.send(message, serializationContext?.sendHandle, e => {
                 if (e && reject)
                     reject(e);
             });

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

@@ -23,7 +23,7 @@ export interface RuntimeWorker {
     on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
     once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
 
-    send(message: RpcMessage, reject?: (e: Error) => void): void;
+    send(message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any): void;
 
     setupRpcPeer(peer: RpcPeer): void;
 }

package/src/plugin/socket-serializer.ts

@@ -0,0 +1,15 @@
+import { RpcSerializer } from "../rpc";
+
+export class SidebandSocketSerializer implements RpcSerializer {
+    serialize(value: any, serializationContext?: any) {
+        if (!serializationContext)
+            throw new Error('socket serialization context unavailable');
+        serializationContext.sendHandle = value;
+    }
+
+    deserialize(serialized: any, serializationContext?: any) {
+        if (!serializationContext)
+            throw new Error('socket deserialization context unavailable');
+        return serializationContext.sendHandle;
+    }
+}