@scrypted/server 0.114.0 → 0.115.1

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@scrypted/server",
-  "version": "0.114.0",
+  "version": "0.115.1",
   "description": "",
   "dependencies": {
     "@mapbox/node-pre-gyp": "^1.0.11",
     "@scrypted/ffmpeg-static": "^6.1.0-build1",
-    "@scrypted/node-pty": "^1.0.14",
-    "@scrypted/types": "^0.3.30",
+    "@scrypted/node-pty": "^1.0.18",
+    "@scrypted/types": "^0.3.43",
     "adm-zip": "^0.5.14",
     "body-parser": "^1.20.2",
     "cookie-parser": "^1.4.6",
     "dotenv": "^16.4.5",
-    "engine.io": "^6.5.4",
+    "engine.io": "^6.6.0",
     "express": "^4.19.2",
     "follow-redirects": "^1.15.6",
     "http-auth": "^4.2.0",
@@ -21,17 +21,17 @@
     "nan": "^2.20.0",
     "node-dijkstra": "^2.5.0",
     "node-forge": "^1.3.1",
-    "node-gyp": "^10.1.0",
-    "py": "npm:@bjia56/portable-python@^0.1.52",
+    "node-gyp": "^10.2.0",
+    "py": "npm:@bjia56/portable-python@^0.1.54",
     "router": "^1.3.8",
-    "semver": "^7.6.2",
+    "semver": "^7.6.3",
     "sharp": "^0.33.4",
     "source-map-support": "^0.5.21",
-    "tar": "^7.4.0",
+    "tar": "^7.4.3",
     "tslib": "^2.6.3",
-    "typescript": "^5.5.2",
+    "typescript": "^5.5.4",
     "whatwg-mimetype": "^4.0.0",
-    "ws": "^8.17.1"
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.5",
@@ -40,13 +40,13 @@
     "@types/follow-redirects": "^1.14.4",
     "@types/http-auth": "^4.1.4",
     "@types/ip": "^1.1.3",
-    "@types/lodash": "^4.17.5",
+    "@types/lodash": "^4.17.7",
     "@types/node-dijkstra": "^2.5.6",
     "@types/node-forge": "^1.3.11",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
     "@types/whatwg-mimetype": "^3.0.2",
-    "@types/ws": "^8.5.10"
+    "@types/ws": "^8.5.11"
   },
   "bin": {
     "scrypted-serve": "bin/scrypted-serve"

package/python/plugin_remote.py

@@ -29,6 +29,7 @@ from plugin_pip import install_with_pip, need_requirements, remove_pip_dirs
 from scrypted_python.scrypted_sdk import PluginFork, ScryptedStatic
 from scrypted_python.scrypted_sdk.types import (Device, DeviceManifest,
                                                 EventDetails,
+                                                ScryptedInterface,
                                                 ScryptedInterfaceMethods,
                                                 ScryptedInterfaceProperty,
                                                 Storage)
@@ -139,6 +140,19 @@ class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
             state = self.systemState.get(check, None)
             if not state:
                 continue
+            checkInterfaces = state.get('interfaces', None)
+            if not checkInterfaces:
+                continue
+            interfaces = checkInterfaces.get('value', [])
+            if ScryptedInterface.ScryptedPlugin.value in interfaces:
+                checkPluginId = state.get('pluginId', None)
+                if not checkPluginId:
+                    continue
+                pluginId = checkPluginId.get('value', None)
+                if not pluginId:
+                    continue
+                if pluginId == name:
+                    return self.getDeviceById(check)
             checkName = state.get('name', None)
             if not checkName:
                 continue
@@ -260,6 +274,13 @@ class DeviceState(scrypted_python.scrypted_sdk.types.DeviceState):
         self.systemManager.api.setState(self.nativeId, property, value)
 
 
+class WritableDeviceState(scrypted_python.scrypted_sdk.types.WritableDeviceState):
+
+    def __init__(self, id, setState) -> None:
+        self.id = id
+        self.setState = setState
+
+
 class DeviceStorage(Storage):
     id: str
     nativeId: str
@@ -390,12 +411,17 @@ class PluginRemote:
 
         def computeClusterObjectHash(o: ClusterObject) -> str:
             m = hashlib.sha256()
-            m.update(bytes(f"{o['id']}{o['port']}{o.get('sourcePort', '')}{o['proxyId']}{clusterSecret}", 'utf8'))
+            m.update(bytes(f"{o['id']}{o['port']}{o.get('sourcePort') or ''}{o['proxyId']}{clusterSecret}", 'utf8'))
             return base64.b64encode(m.digest()).decode('utf-8')
 
-        def onProxySerialization(value: Any, proxyId: str, sourcePeerPort: int = None):
+        def onProxySerialization(value: Any, sourcePeerPort: int = None):
             properties: dict = rpc.RpcPeer.prepareProxyProperties(value) or {}
             clusterEntry = properties.get('__cluster', None)
+            proxyId: str = (clusterEntry and clusterEntry.get('proxyId', None)) or rpc.RpcPeer.generateId()
+
+            if clusterEntry and clusterPort == clusterEntry['port'] and sourcePeerPort != clusterEntry.get('sourcePort', None):
+                clusterEntry = None
+
             if not properties.get('__cluster', None):
                 clusterEntry: ClusterObject = {
                     'id': clusterId,
@@ -406,7 +432,7 @@ class PluginRemote:
                 clusterEntry['sha256'] = computeClusterObjectHash(clusterEntry)
                 properties['__cluster'] = clusterEntry
 
-            return properties
+            return proxyId, properties
 
         self.peer.onProxySerialization = onProxySerialization
 
@@ -423,8 +449,8 @@ class PluginRemote:
             rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
             peer: rpc.RpcPeer
             peer, peerReadLoop = await rpc_reader.prepare_peer_readloop(self.loop, rpcTransport)
-            peer.onProxySerialization = lambda value, proxyId: onProxySerialization(
-                value, proxyId, clusterPeerPort)
+            peer.onProxySerialization = lambda value: onProxySerialization(
+                value, clusterPeerPort)
             future: asyncio.Future[rpc.RpcPeer] = asyncio.Future()
             future.set_result(peer)
             clusterPeers[clusterPeerPort] = future
@@ -458,9 +484,8 @@ class PluginRemote:
                     rpcTransport = rpc_reader.RpcStreamTransport(
                         reader, writer)
                     clusterPeer, peerReadLoop = await rpc_reader.prepare_peer_readloop(self.loop, rpcTransport)
-                    clusterPeer.tags['localPort'] = clusterPeerPort
-                    clusterPeer.onProxySerialization = lambda value, proxyId: onProxySerialization(
-                        value, proxyId, clusterPeerPort)
+                    clusterPeer.onProxySerialization = lambda value: onProxySerialization(
+                        value, clusterPeerPort)
 
                     async def run_loop():
                         try:
@@ -494,8 +519,11 @@ class PluginRemote:
 
             try:
                 clusterPeer = await clusterPeerPromise
-                if clusterPeer.tags.get('localPort') == sourcePort:
-                    return value
+                weakref = clusterPeer.remoteWeakProxies.get(proxyId, None)
+                existing = weakref() if weakref else None
+                if existing:
+                    return existing
+
                 peerConnectRPCObject = clusterPeer.tags.get('connectRPCObject')
                 if not peerConnectRPCObject:
                     peerConnectRPCObject = await clusterPeer.getParam('connectRPCObject')
@@ -743,7 +771,7 @@ class PluginRemote:
         pass
 
     async def createDeviceState(self, id, setState):
-        pass
+        return WritableDeviceState(id, setState)
 
     async def getServicePort(self, name):
         if name == "repl":

package/python/rpc.py

@@ -126,7 +126,7 @@ class RpcPeer:
         self.pendingResults: Mapping[str, Future] = {}
         self.remoteWeakProxies: Mapping[str, any] = {}
         self.nameDeserializerMap: Mapping[str, RpcSerializer] = {}
-        self.onProxySerialization: Callable[[Any, str], Any] = None
+        self.onProxySerialization: Callable[[Any, str], tuple[str, Any]] = None
         self.killed = False
         self.tags = {}
 
@@ -274,7 +274,7 @@ class RpcPeer:
 
         proxiedEntry = self.localProxied.get(value, None)
         if proxiedEntry:
-            proxiedEntry['finalizerId'] = self.generateId()
+            proxiedEntry['finalizerId'] = RpcPeer.generateId()
             ret = {
                 '__remote_proxy_id': proxiedEntry['id'],
                 '__remote_proxy_finalizer_id': proxiedEntry['finalizerId'],
@@ -292,7 +292,12 @@ class RpcPeer:
             }
             return ret
 
-        proxyId = self.generateId()
+        if self.onProxySerialization:
+            proxyId, __remote_proxy_props = self.onProxySerialization(value)
+        else:
+            __remote_proxy_props = RpcPeer.prepareProxyProperties(value)
+            proxyId = RpcPeer.generateId()
+
         proxiedEntry = {
             'id': proxyId,
             'finalizerId': proxyId,
@@ -300,11 +305,6 @@ class RpcPeer:
         self.localProxied[value] = proxiedEntry
         self.localProxyMap[proxyId] = value
 
-        if self.onProxySerialization:
-            __remote_proxy_props = self.onProxySerialization(value, proxyId)
-        else:
-            __remote_proxy_props = RpcPeer.prepareProxyProperties(value)
-
         ret = {
             '__remote_proxy_id': proxyId,
             '__remote_proxy_finalizer_id': proxyId,
@@ -491,7 +491,7 @@ class RpcPeer:
 
     randomDigits = string.ascii_uppercase + string.ascii_lowercase + string.digits
 
-    def generateId(self):
+    def generateId():
         return ''.join(random.choices(RpcPeer.randomDigits, k=8))
 
     async def createPendingResult(self, cb: Callable[[str, Callable[[Exception], None]], None]):
@@ -500,7 +500,7 @@ class RpcPeer:
             future.set_exception(RPCResultError(None, 'RpcPeer has been killed (createPendingResult)'))
             return future
 
-        id = self.generateId()
+        id = RpcPeer.generateId()
         self.pendingResults[id] = future
         await cb(id, lambda e: future.set_exception(RPCResultError(e, None)))
         return await future

package/src/fetch/http-fetch.ts

@@ -89,11 +89,11 @@ export async function httpFetch<T extends HttpFetchOptions<Readable>>(options: T
         controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), options.timeout);
 
-        options.signal?.addEventListener('abort', () => controller.abort('abort'));
+        options.signal?.addEventListener('abort', () => controller.abort(options.signal?.reason));
     }
 
     const signal = controller?.signal || options.signal;
-    signal?.addEventListener('abort', () => request.destroy(new Error('abort')));
+    signal?.addEventListener('abort', () => request.destroy(new Error(options.signal?.reason || 'abort')));
 
     const nodeHeaders: Record<string, string[]> = {};
     for (const [k, v] of headers) {
@@ -122,9 +122,12 @@ export async function httpFetch<T extends HttpFetchOptions<Readable>>(options: T
     try {
         const [response] = await once(request, 'response') as [IncomingMessage];
 
-        if (!options?.ignoreStatusCode) {
+
+        if (options?.checkStatusCode === undefined || options?.checkStatusCode) {
             try {
-                checkStatus(response.statusCode);
+                const checker = typeof options?.checkStatusCode === 'function' ? options.checkStatusCode : checkStatus;
+                if (!checker(response.statusCode))
+                    throw new Error(`http response statusCode ${response.statusCode}`);
             }
             catch (e) {
                 readMessageBuffer(response).catch(() => { });
@@ -150,31 +153,3 @@ export async function httpFetch<T extends HttpFetchOptions<Readable>>(options: T
     }
 }
 
-function ensureType<T>(v: T) {
-}
-
-async function test() {
-    const a = await httpFetch({
-        url: 'http://example.com',
-    });
-
-    ensureType<Buffer>(a.body);
-
-    const b = await httpFetch({
-        url: 'http://example.com',
-        responseType: 'json',
-    });
-    ensureType<any>(b.body);
-
-    const c = await httpFetch({
-        url: 'http://example.com',
-        responseType: 'readable',
-    });
-    ensureType<IncomingMessage>(c.body);
-
-    const d = await httpFetch({
-        url: 'http://example.com',
-        responseType: 'buffer',
-    });
-    ensureType<Buffer>(d.body);
-}

package/src/fetch/index.ts

@@ -7,7 +7,10 @@ export interface HttpFetchOptionsBase<B> {
     signal?: AbortSignal,
     timeout?: number;
     rejectUnauthorized?: boolean;
-    ignoreStatusCode?: boolean;
+    /**
+     * Checks the status code. Defaults to true.
+     */
+    checkStatusCode?: boolean | ((statusCode: number) => boolean);
     body?: B | string | ArrayBufferView | any;
     withCredentials?: boolean;
 }
@@ -40,6 +43,7 @@ export function fetchStatusCodeOk(statusCode: number) {
 export function checkStatus(statusCode: number) {
     if (!fetchStatusCodeOk(statusCode))
         throw new Error(`http response statusCode ${statusCode}`);
+    return true;
 }
 
 export function getFetchMethod(options: HttpFetchOptions<any>) {
@@ -177,7 +181,7 @@ export async function domFetch<T extends HttpFetchOptions<BodyInit>>(options: T)
         controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), options.timeout);
 
-        options.signal?.addEventListener('abort', () => controller.abort('abort'));
+        options.signal?.addEventListener('abort', () => controller.abort(options.signal?.reason));
     }
 
     try {
@@ -190,9 +194,11 @@ export async function domFetch<T extends HttpFetchOptions<BodyInit>>(options: T)
             body,
         });
 
-        if (!options?.ignoreStatusCode) {
+        if (options?.checkStatusCode === undefined || options?.checkStatusCode) {
             try {
-                checkStatus(response.status);
+                const checker = typeof options?.checkStatusCode === 'function' ? options.checkStatusCode : checkStatus;
+                if (!checker(response.status))
+                    throw new Error(`http response statusCode ${response.status}`);
             }
             catch (e) {
                 response.arrayBuffer().catch(() => { });
@@ -210,32 +216,3 @@ export async function domFetch<T extends HttpFetchOptions<BodyInit>>(options: T)
         clearTimeout(timeout);
     }
 }
-
-function ensureType<T>(v: T) {
-}
-
-async function test() {
-    const a = await domFetch({
-        url: 'http://example.com',
-    });
-
-    ensureType<Buffer>(a.body);
-
-    const b = await domFetch({
-        url: 'http://example.com',
-        responseType: 'json',
-    });
-    ensureType<any>(b.body);
-
-    const c = await domFetch({
-        url: 'http://example.com',
-        responseType: 'readable',
-    });
-    ensureType<Response>(c.body);
-
-    const d = await domFetch({
-        url: 'http://example.com',
-        responseType: 'buffer',
-    });
-    ensureType<Buffer>(d.body);
-}

package/src/listen-zero.ts

@@ -7,13 +7,13 @@ export class ListenZeroSingleClientTimeoutError extends Error {
     }
 }
 
-export async function listenZero(server: net.Server, hostname?: string) {
-    server.listen(0, hostname);
+export async function listenZero(server: net.Server, hostname: string) {
+    server.listen(0, hostname || '127.0.0.1');
     await once(server, 'listening');
     return (server.address() as net.AddressInfo).port;
 }
 
-export async function listenZeroSingleClient(hostname?: string, options?: net.ServerOpts, listenTimeout = 30000) {
+export async function listenZeroSingleClient(hostname: string, options?: net.ServerOpts, listenTimeout = 30000) {
     const server = new net.Server(options);
     const port = await listenZero(server, hostname);
 

package/src/plugin/plugin-console.ts

@@ -295,8 +295,8 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
         socket.once('error', cleanup);
         socket.once('end', cleanup);
     });
-    const readPort = await listenZero(readServer);
-    const writePort = await listenZero(writeServer);
+    const readPort = await listenZero(readServer, '127.0.0.1');
+    const writePort = await listenZero(writeServer, '127.0.0.1');
 
     return {
         clear(nativeId: ScryptedNativeId) {

package/src/plugin/plugin-npm-dependencies.ts

@@ -9,8 +9,12 @@ import { ensurePluginVolume } from "./plugin-volume";
 
 export function defaultNpmExec(args: string[], options: child_process.SpawnOptions) {
     let npm = 'npm';
-    if (os.platform() === 'win32')
+    if (os.platform() === 'win32') {
         npm += '.cmd';
+        // wrap each argument in a quote to handle spaces in paths
+        // https://github.com/nodejs/node/issues/38490#issuecomment-927330248
+        args = args.map(arg => '"' + arg + '"');
+    }
     const cp = child_process.spawn(npm, args, options);
     return cp;
 }

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

@@ -9,6 +9,7 @@ import { computeClusterObjectHash } from '../cluster/cluster-hash';
 import { ClusterObject, ConnectRPCObject } from '../cluster/connect-rpc-object';
 import { listenZero } from '../listen-zero';
 import { RpcMessage, RpcPeer } from '../rpc';
+import { evalLocal } from '../rpc-peer-eval';
 import { createDuplexRpcPeer } from '../rpc-serializer';
 import { MediaManagerImpl } from './media';
 import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
@@ -95,10 +96,19 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             const { clusterId, clusterSecret, zipHash } = zipOptions;
             const { zipFile, unzippedPath } = await prepareZip(getPluginVolume(pluginId), zipHash, getZip);
 
-            const onProxySerialization = (value: any, proxyId: string, sourcePeerPort?: number) => {
+            const onProxySerialization = (value: any, sourcePeerPort?: number) => {
                 const properties = RpcPeer.prepareProxyProperties(value) || {};
                 let clusterEntry: ClusterObject = properties.__cluster;
 
+                // ensure globally stable proxyIds.
+                const proxyId = clusterEntry?.proxyId || RpcPeer.generateId();
+
+                // if the cluster entry already exists, check if it belongs to this node.
+                // if it belongs to this node, the entry must also be for this peer.
+                // relying on the liveness/gc of a different peer may cause race conditions.
+                if (clusterEntry && clusterPort === clusterEntry.port && sourcePeerPort !== clusterEntry.sourcePort)
+                    clusterEntry = undefined;
+
                 // set the cluster identity if it does not exist.
                 if (!clusterEntry) {
                     clusterEntry = {
@@ -111,12 +121,11 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                     clusterEntry.sha256 = computeClusterObjectHash(clusterEntry, clusterSecret);
                     properties.__cluster = clusterEntry;
                 }
-                // always reassign the id and source.
-                // if this is already a p2p object, and is passed to a different peer,
-                // a future p2p object must be routed to the correct p2p peer to find the object.
-                // clusterEntry.proxyId = proxyId;
-                // clusterEntry.source = source;
-                return properties;
+
+                return {
+                    proxyId,
+                    properties,
+                };
             }
             peer.onProxySerialization = onProxySerialization;
 
@@ -133,7 +142,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             const clusterRpcServer = net.createServer(client => {
                 const clusterPeer = createDuplexRpcPeer(peer.selfName, 'cluster-client', client, client);
                 const clusterPeerPort = client.remotePort;
-                clusterPeer.onProxySerialization = (value, proxyId) => onProxySerialization(value, proxyId, clusterPeerPort);
+                clusterPeer.onProxySerialization = (value) => onProxySerialization(value, clusterPeerPort);
                 clusterPeers.set(clusterPeerPort, Promise.resolve(clusterPeer));
                 startPluginRemoteOptions?.onClusterPeer?.(clusterPeer);
                 const connectRPCObject: ConnectRPCObject = async (o) => {
@@ -164,8 +173,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                             const sourcePort = (socket.address() as net.AddressInfo).port;
 
                             const clusterPeer = createDuplexRpcPeer(peer.selfName, 'cluster-server', socket, socket);
-                            clusterPeer.tags.localPort = sourcePort;
-                            clusterPeer.onProxySerialization = (value, proxyId) => onProxySerialization(value, proxyId, sourcePort);
+                            clusterPeer.onProxySerialization = (value) => onProxySerialization(value, sourcePort);
                             return clusterPeer;
                         }
                         catch (e) {
@@ -192,10 +200,10 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 try {
                     const clusterPeerPromise = ensureClusterPeer(port);
                     const clusterPeer = await clusterPeerPromise;
-                    // if the localPort is the sourcePort, that means the rpc object already exists as it originated from this node.
-                    // so return the existing proxy.
-                    if (clusterPeer.tags.localPort === sourcePort)
-                        return value;
+                    // the proxy id is guaranteed to be unique in all peers in a cluster
+                    const existing = clusterPeer.remoteWeakProxies[proxyId]?.deref();
+                    if (existing)
+                        return existing;
                     let peerConnectRPCObject: ConnectRPCObject = clusterPeer.tags['connectRPCObject'];
                     if (!peerConnectRPCObject) {
                         peerConnectRPCObject = await clusterPeer.getParam('connectRPCObject');
@@ -269,11 +277,11 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
                 process.on('uncaughtException', e => {
                     getPluginConsole().error('uncaughtException', e);
-                    scrypted.log.e('uncaughtException ' + e?.toString());
+                    scrypted.log.e('uncaughtException ' + (e.stack || e?.toString()));
                 });
                 process.on('unhandledRejection', e => {
                     getPluginConsole().error('unhandledRejection', e);
-                    scrypted.log.e('unhandledRejection ' + e?.toString());
+                    scrypted.log.e('unhandledRejection ' + ((e as Error).stack || e?.toString()));
                 });
 
                 installSourceMapSupport({
@@ -376,7 +384,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
             try {
                 const filename = zipOptions?.debug ? '/plugin/main.nodejs.js' : `/${pluginId}/main.nodejs.js`;
-                peer.evalLocal(script, filename, params);
+                evalLocal(peer, script, filename, params);
 
                 if (zipOptions?.fork) {
                     // pluginConsole?.log('plugin forked');

package/src/plugin/plugin-remote.ts

@@ -179,7 +179,6 @@ class DeviceStateProxyHandler implements ProxyHandler<any> {
 
     set?(target: any, p: PropertyKey, value: any, receiver: any) {
         checkProperty(p.toString(), value);
-        const now = Date.now();
         this.deviceManager.systemManager.state[this.id][p as string] = {
             value,
         };
@@ -446,7 +445,7 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
         return remote;
     }
     catch (e) {
-        throw new RPCResultError(peer, 'error while retrieving PluginRemote', e);
+        throw new RPCResultError(peer, 'error while retrieving PluginRemote', e as Error);
     }
 }
 

package/src/plugin/plugin-repl.ts

@@ -75,5 +75,5 @@ export async function createREPLServer(scrypted: ScryptedStatic, params: any, pl
         socket.on('error', cleanup);
         socket.on('end', cleanup);
     });
-    return listenZero(server);
+    return listenZero(server, '127.0.0.1');
 }

package/src/rpc-peer-eval.ts

@@ -0,0 +1,27 @@
+import type { CompileFunctionOptions } from 'vm';
+import { RpcPeer } from "./rpc";
+
+type CompileFunction = (code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions) => Function;
+
+function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): any {
+    params = params || [];
+    const f = `(function(${params.join(',')}) {;${code};})`;
+    return eval(f);
+}
+
+export function evalLocal<T>(peer: RpcPeer, script: string, filename?: string, coercedParams?: { [name: string]: any }): T {
+    const params = Object.assign({}, peer.params, coercedParams);
+    let compile: CompileFunction;
+    try {
+        // prevent bundlers from trying to include non-existent vm module.
+        compile = module[`require`]('vm').compileFunction;
+    }
+    catch (e) {
+        compile = compileFunction;
+    }
+    const f = compile(script, Object.keys(params), {
+        filename,
+    });
+    const value = f(...Object.values(params));
+    return value;
+}

package/src/rpc-serializer.ts

@@ -10,7 +10,7 @@ export function createDuplexRpcPeer(selfName: string, peerName: string, readable
             serializer.sendMessage(message, reject, serializationContext);
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
             readable.destroy();
         }
     });
@@ -165,7 +165,7 @@ export function createRpcDuplexSerializer(writable: {
                     serializer.onMessageFinish(message);
                 }
                 catch (e) {
-                    serializer.kill('message parse failure ' + e.message);
+                    serializer.kill('message parse failure ' + (e as Error).message);
                 }
             }
             else {