@scrypted/server 0.123.22 → 0.123.24

package/src/plugin/plugin-host.ts

@@ -4,13 +4,13 @@ import * as io from 'engine.io';
 import fs from 'fs';
 import os from 'os';
 import WebSocket from 'ws';
+import { setupCluster } from '../cluster/cluster-setup';
 import { Plugin } from '../db-types';
 import { IOServer, IOServerSocket } from '../io';
 import { Logger } from '../logger';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { createRpcSerializer } from '../rpc-serializer';
 import { ScryptedRuntime } from '../runtime';
-import { setupCluster } from '../cluster/cluster-setup';
 import { sleep } from '../sleep';
 import { AccessControls } from './acl';
 import { MediaManagerHostImpl } from './media';
@@ -20,7 +20,6 @@ import { PluginDebug } from './plugin-debug';
 import { PluginHostAPI } from './plugin-host-api';
 import { LazyRemote } from './plugin-lazy-remote';
 import { setupPluginRemote } from './plugin-remote';
-import { PluginStats } from './plugin-remote-stats';
 import { WebSocketConnection } from './plugin-remote-websocket';
 import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
 import { createClusterForkWorker, needsClusterForkWorker } from './runtime/cluster-fork.worker';
@@ -60,8 +59,6 @@ export class PluginHost {
     api: PluginHostAPI;
     pluginName: string;
     packageJson: any;
-    lastStats: number;
-    stats: PluginStats;
     killed = false;
     consoleServer: Promise<ConsoleServer>;
     zipHash: string;
@@ -173,7 +170,6 @@ export class PluginHost {
                     return;
                 }
 
-
                 const handler = this.scrypted.getDevice<EngineIOHandler>(pluginDevice._id);
 
                 // @ts-expect-error
@@ -202,8 +198,6 @@ export class PluginHost {
             }
         })
 
-        const self = this;
-
         const { runtime } = this.packageJson.scrypted;
         const mediaManager = runtime && runtime !== 'node'
             ? new MediaManagerHostImpl(pluginDeviceId, () => scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
@@ -214,79 +208,120 @@ export class PluginHost {
         logger.log('i', `loading ${this.pluginName}`);
         logger.log('i', 'pid ' + this.worker?.pid);
 
-        const remotePromise = (async () => {
-            let peer: RpcPeer;
+        const remotePromise = this.prepareRemote(peerPromise, logger, pluginDebug);
+        const init = this.initializeRemote(remotePromise, logger, pluginDebug);
+
+        init.catch(e => {
+            console.error('plugin failed to load', e);
+            this.api.removeListeners();
+        });
+
+        this.module = init.then(({ module }) => module);
+        const remote = init.then(({ remote }) => remote);
+        this.remote = new LazyRemote(remotePromise, remote);
+    }
+
+    private async initializeRemote(remotePromise: Promise<PluginRemote>, logger: Logger, pluginDebug: PluginDebug) {
+        const remote = await remotePromise;
+
+        await Promise.all(
+            this.scrypted.findPluginDevices(this.pluginId)
+                .map(pluginDevice => remote.setNativeId(pluginDevice.nativeId, pluginDevice._id, pluginDevice.storage || {}))
+        );
+
+        const waitDebug = pluginDebug?.waitDebug;
+        if (waitDebug) {
+            console.info('waiting for debugger...');
             try {
-                peer = await peerPromise;
+                await waitDebug;
+                console.info('debugger attached.');
+                await sleep(1000);
             }
             catch (e) {
-                logger.log('e', 'plugin failed to start ' + e);
-                throw new RPCResultError(this.peer, 'cluster plugin start failed', e);
+                console.error('debugger failed', e);
             }
-            return setupPluginRemote(peer, this.api, self.pluginId, { serverVersion }, () => this.scrypted.stateManager.getSystemState());
-        })();
+        }
 
-        const init = (async () => {
-            const remote = await remotePromise;
+        const fail = 'Plugin failed to load. View Console for more information.';
+        try {
+            const loadZipOptions: PluginRemoteLoadZipOptions = {
+                clusterId: this.scrypted.clusterId,
+                clusterSecret: this.scrypted.clusterSecret,
+                // debug flag can be used to affect path resolution for sourcemaps etc.
+                debug: !!pluginDebug,
+                zipHash: this.zipHash,
+            };
+            // original implementation sent the zipBuffer, sending the zipFile name now.
+            // can switch back for non-local plugins.
+            const modulePromise = remote.loadZip(this.packageJson,
+                new PluginZipAPI(async () => fs.promises.readFile(this.zipFile)),
+                loadZipOptions);
+            // allow garbage collection of the zip buffer
+            const module = await modulePromise;
+            logger.log('i', `loaded ${this.pluginName}`);
+            logger.clearAlert(fail)
+            return { module, remote };
+        }
+        catch (e) {
+            logger.log('a', fail);
+            logger.log('e', `plugin load error ${e}`);
+            console.error('plugin load error', e);
+            throw e;
+        }
+    }
 
-            await Promise.all(
-                scrypted.findPluginDevices(self.pluginId)
-                    .map(pluginDevice => remote.setNativeId(pluginDevice.nativeId, pluginDevice._id, pluginDevice.storage || {}))
-            );
+    private async prepareRemote(peerPromise: Promise<RpcPeer>, logger: Logger, pluginDebug: PluginDebug) {
+        let peer: RpcPeer;
+        try {
+            peer = await peerPromise;
+        }
+        catch (e) {
+            logger.log('e', 'plugin failed to start ' + e);
+            throw new RPCResultError(this.peer, 'cluster plugin start failed', e);
+        }
 
-            const waitDebug = pluginDebug?.waitDebug;
-            if (waitDebug) {
-                console.info('waiting for debugger...');
-                try {
-                    await waitDebug;
-                    console.info('debugger attached.');
-                    await sleep(1000);
-                }
-                catch (e) {
-                    console.error('debugger failed', e);
-                }
-            }
+        const startupTime = Date.now();
+        let lastPong: number;
 
-            const fail = 'Plugin failed to load. View Console for more information.';
+        (async () => {
             try {
-                const loadZipOptions: PluginRemoteLoadZipOptions = {
-                    clusterId: scrypted.clusterId,
-                    clusterSecret: scrypted.clusterSecret,
-                    // debug flag can be used to affect path resolution for sourcemaps etc.
-                    debug: !!pluginDebug,
-                    zipHash: this.zipHash,
-                };
-                // original implementation sent the zipBuffer, sending the zipFile name now.
-                // can switch back for non-local plugins.
-                const modulePromise = remote.loadZip(this.packageJson,
-                    // the plugin is expected to send process stats every 10 seconds.
-                    // this can be used as a check for liveness.
-                    new PluginZipAPI(async () => fs.promises.readFile(this.zipFile), async (stats: PluginStats) => {
-                        this.lastStats = Date.now();
-                        this.stats = stats;
-                    }),
-                    loadZipOptions);
-                // allow garbage collection of the zip buffer
-                const module = await modulePromise;
-                logger.log('i', `loaded ${this.pluginName}`);
-                logger.clearAlert(fail)
-                return { module, remote };
+                let pingPromise: Promise<(time: number) => Promise<number>>
+                while (!this.killed) {
+                    await sleep(30000);
+                    if (this.killed)
+                        return;
+                    pingPromise ||= peer.getParam('ping');
+                    const ping = await pingPromise;
+                    lastPong = await ping(Date.now());
+                }
             }
             catch (e) {
-                logger.log('a', fail);
-                logger.log('e', `plugin load error ${e}`);
-                console.error('plugin load error', e);
-                throw e;
+                logger.log('e', 'plugin ping failed. restarting.');
+                this.api.requestRestart();
             }
         })();
 
-        this.module = init.then(({ module }) => module);
-        this.remote = new LazyRemote(remotePromise, init.then(({ remote }) => remote));
+        const healthInterval = setInterval(async () => {
+            const now = Date.now();
+            // plugin may take a while to install, so wait 10 minutes.
+            // after that, require 1 minute checkins.
+            if (!lastPong) {
+                if (now - startupTime > 10 * 60 * 1000) {
+                    const logger = await this.api.getLogger(undefined);
+                    logger.log('e', 'plugin failed to start in a timely manner. restarting.');
+                    this.api.requestRestart();
+                }
+                return;
+            }
+            if (!pluginDebug && (lastPong + 60000 < now)) {
+                const logger = await this.api.getLogger(undefined);
+                logger.log('e', 'plugin is not responding to ping. restarting.');
+                this.api.requestRestart();
+            }
+        }, 60000);
+        peer.killedSafe.finally(() => clearInterval(healthInterval));
 
-        init.catch(e => {
-            console.error('plugin failed to load', e);
-            this.api.removeListeners();
-        });
+        return setupPluginRemote(peer, this.api, this.pluginId, { serverVersion }, () => this.scrypted.stateManager.getSystemState());
     }
 
     startPluginHost(logger: Logger, env: any, pluginDebug: PluginDebug) {
@@ -355,9 +390,9 @@ export class PluginHost {
 
             forkPeer.then(peer => {
                 const originalPeer = this.peer;
-                originalPeer.killed.then(s => peer.kill(s)).catch(e => peer.kill(e));
+                originalPeer.killedSafe.finally(() => peer.kill());
                 this.peer = peer;
-                peer.killed.catch(() =>{} ).finally(() => originalPeer.kill());
+                peer.killedSafe.finally(() => originalPeer.kill());
             }).catch(() => {});
 
             this.worker = runtimeWorker;
@@ -387,54 +422,6 @@ export class PluginHost {
             disconnect();
         });
 
-        const startupTime = Date.now();
-        let lastPong: number;
-        const pong = (time: number) => {
-            lastPong = time;
-        };
-        (async () => {
-            try {
-                let pingPromise: Promise<(time: number, p: typeof pong) => Promise<void>>
-                while (!this.killed) {
-                    await sleep(30000);
-                    if (this.killed)
-                        return;
-                    pingPromise ||= this.peer.getParam('ping');
-                    const ping = await pingPromise;
-                    await ping(Date.now(), pong);
-                }
-            }
-            catch (e) {
-                logger.log('e', 'plugin ping failed. restarting.');
-                this.api.requestRestart();
-            }
-        })();
-
-        const healthInterval = setInterval(async () => {
-            const now = Date.now();
-            // plugin may take a while to install, so wait 10 minutes.
-            // after that, require 1 minute checkins.
-            if (!this.lastStats || !lastPong) {
-                if (now - startupTime > 10 * 60 * 1000) {
-                    const logger = await this.api.getLogger(undefined);
-                    logger.log('e', 'plugin failed to start in a timely manner. restarting.');
-                    this.api.requestRestart();
-                }
-                return;
-            }
-            if (!pluginDebug && (this.lastStats + 60000 < now)) {
-                const logger = await this.api.getLogger(undefined);
-                logger.log('e', 'plugin is not reporting stats. restarting.');
-                this.api.requestRestart();
-            }
-            if (!pluginDebug && (lastPong + 60000 < now)) {
-                const logger = await this.api.getLogger(undefined);
-                logger.log('e', 'plugin is not responding to ping. restarting.');
-                this.api.requestRestart();
-            }
-        }, 60000);
-        this.peer.killed.finally(() => clearInterval(healthInterval));
-
         return peer;
     }
 

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

@@ -15,6 +15,7 @@ import { PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin
             this.remote = await remoteReadyPromise;
             return this.remote;
         })();
+        this.remoteReadyPromise.catch(() => {});
     }
 
     async loadZip(packageJson: any, zipAPI: PluginZipAPI, options?: PluginRemoteLoadZipOptions): Promise<any> {

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

@@ -12,7 +12,6 @@ import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions, Pl
 import { pipeWorkerConsole, prepareConsoles } from './plugin-console';
 import { getPluginNodePath, installOptionalDependencies } from './plugin-npm-dependencies';
 import { attachPluginRemote, DeviceManagerImpl, setupPluginRemote } from './plugin-remote';
-import { PluginStats, startStatsUpdater } from './plugin-remote-stats';
 import { createREPLServer } from './plugin-repl';
 import { getPluginVolume } from './plugin-volume';
 import { ChildProcessWorker } from './runtime/child-process-worker';
@@ -33,7 +32,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
     const peer = new RpcPeer('unknown', 'host', peerSend);
 
     const clusterPeerSetup = setupCluster(peer);
-    const { initializeCluster, connectRPCObject, mainThreadBrokerRegister , mainThreadPort } = clusterPeerSetup;
+    const { initializeCluster, connectRPCObject, mainThreadBrokerRegister, mainThreadPort } = clusterPeerSetup;
 
     peer.params.initializeCluster = initializeCluster;
 
@@ -196,14 +195,8 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
             await installOptionalDependencies(getPluginConsole(), packageJson);
 
-            // process.cpuUsage is for the entire process.
-            // process.memoryUsage is per thread.
-            const allMemoryStats = new Map<RuntimeWorker, NodeJS.MemoryUsage>();
-            // start the stats updater/watchdog after installation has finished, as that may take some time.
-            startStatsUpdater(allMemoryStats, zipAPI.updateStats);
-
-            peer.params.ping = async (time: number, pong: (time: number) => Promise<void>) => {
-                await pong(time);
+            peer.params.ping = async (time: number) => {
+                return time;
             };
 
             const main = pluginReader(mainNodejs);
@@ -315,13 +308,11 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         threadPeer.kill('worker exited');
                         forkApi.removeListeners();
                         forks.delete(remote);
-                        allMemoryStats.delete(runtimeWorker);
                     });
                     runtimeWorker.on('error', e => {
                         threadPeer.kill('worker error ' + e);
                         forkApi.removeListeners();
                         forks.delete(remote);
-                        allMemoryStats.delete(runtimeWorker);
                     });
 
                     for (const [nativeId, dmd] of deviceManager.nativeIds.entries()) {
@@ -331,9 +322,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                     const forkOptions = Object.assign({}, zipOptions);
                     forkOptions.fork = true;
                     forkOptions.main = options?.filename;
-                    const forkZipAPI = new PluginZipAPI(() => zipAPI.getZip(), async (stats: PluginStats) => {
-                        allMemoryStats.set(runtimeWorker, stats.memoryUsage);
-                    });
+                    const forkZipAPI = new PluginZipAPI(() => zipAPI.getZip());
                     return remote.loadZip(packageJson, forkZipAPI, forkOptions)
                 })();
 

package/src/rpc.ts

@@ -300,6 +300,7 @@ export class RpcPeer {
     constructorSerializerMap = new Map<any, string>();
     transportSafeArgumentTypes = RpcPeer.getDefaultTransportSafeArgumentTypes();
     killed: Promise<string>;
+    killedSafe: Promise<void>;
     killedDeferred: Deferred;
     tags: any = {};
     yieldedAsyncIterators = new Set<AsyncGenerator>();
@@ -395,6 +396,7 @@ export class RpcPeer {
         this.killed = new Promise<string>((resolve, reject) => {
             this.killedDeferred = { resolve, reject, method: undefined };
         }).catch(e => e.message || 'Unknown Error');
+        this.killedSafe = this.killed.then(() => {}).catch(() => { });
     }
 
     static isTransportSafe(value: any) {

package/src/scrypted-cluster-main.ts

@@ -1,3 +1,4 @@
+import os from 'os';
 import type { ForkOptions } from '@scrypted/types';
 import { once } from 'events';
 import net from 'net';
@@ -39,7 +40,7 @@ function peerLifecycle(serializer: ReturnType<typeof createRpcDuplexSerializer>,
     socket.on('close', () => {
         peer.kill(`cluster ${type} closed`);
     });
-    peer.killed.then(() => {
+    peer.killedSafe.finally(() => {
         socket.destroy();
     });
 }
@@ -68,6 +69,7 @@ export interface ClusterWorkerProperties {
 
 export interface ClusterWorker extends ClusterWorkerProperties {
     peer: RpcPeer;
+    forks: Set<ClusterForkOptions>;
 }
 
 export class PeerLiveness {
@@ -120,7 +122,7 @@ export function startClusterClient(mainFilename: string) {
             try {
                 await once(rawSocket, 'connect');
             }
-            catch( e) {
+            catch (e) {
                 continue;
             }
 
@@ -154,7 +156,7 @@ export function startClusterClient(mainFilename: string) {
                 const auth: ClusterObject = {
                     address: socket.localAddress,
                     port: socket.localPort,
-                    id: undefined,
+                    id: process.env.SCRYPTED_CLUSTER_ID || os.hostname(),
                     proxyId: undefined,
                     sourceKey: undefined,
                     sha256: undefined,
@@ -208,17 +210,19 @@ export function startClusterClient(mainFilename: string) {
                     runtimeWorker.on('error', e => {
                         threadPeer.kill('worker error ' + e);
                     });
-                    threadPeer.killed.catch(() => { }).finally(() => {
+                    threadPeer.killedSafe.finally(() => {
                         runtimeWorker.kill();
                     });
                     peerLiveness.waitKilled().catch(() => { }).finally(() => {
                         threadPeer.kill('peer killed');
                     });
                     let getRemote: any;
+                    let ping: any;
                     try {
                         const initializeCluster: InitializeCluster = await threadPeer.getParam('initializeCluster');
                         await initializeCluster({ clusterId, clusterSecret });
                         getRemote = await threadPeer.getParam('getRemote');
+                        ping = await threadPeer.getParam('ping');
                     }
                     catch (e) {
                         threadPeer.kill('cluster fork failed');
@@ -241,6 +245,7 @@ export function startClusterClient(mainFilename: string) {
                             stdout: readStream(runtimeWorker.stdout),
                             stderr: readStream(runtimeWorker.stderr),
                             getRemote,
+                            ping,
                         };
                     };
 
@@ -254,9 +259,12 @@ export function startClusterClient(mainFilename: string) {
             }
             catch (e) {
                 peer.kill(e.message);
-                socket.destroy();
                 console.warn('Cluster client error:', localAddress, localPort, e);
             }
+            finally {
+                peer.kill();
+                socket.destroy();
+            }
         }
     })();
 }
@@ -278,6 +286,9 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
                 const sha256 = computeClusterObjectHash(auth, runtime.clusterSecret);
                 if (sha256 !== auth.sha256)
                     throw new Error('cluster object hash mismatch');
+
+                peer.peerName = auth.id || `${socket.remoteAddress}`;
+
                 // the remote address may be ipv6 prefixed so use a fuzzy match.
                 // eg ::ffff:192.168.2.124
                 if (!process.env.SCRYPTED_DISABLE_CLUSTER_SERVER_TRUST) {
@@ -287,9 +298,10 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
                 const worker: ClusterWorker = {
                     ...properties,
                     peer,
+                    forks: new Set(),
                 };
                 runtime.clusterWorkers.add(worker);
-                peer.killed.then(() => {
+                peer.killedSafe.finally(() => {
                     runtime.clusterWorkers.delete(worker);
                 });
                 socket.on('close', () => {

package/src/services/cluster-fork.ts

@@ -18,7 +18,12 @@ export class ClusterFork {
             throw new Error(`no worker found for cluster labels ${JSON.stringify(options.labels)}`);
 
         const fork: ClusterForkParam = await worker.peer.getParam('fork');
-        return fork(peerLiveness, options.runtime, packageJson, zipHash, getZip);
+        const forkResult = await fork(peerLiveness, options.runtime, packageJson, zipHash, getZip);
+        worker.forks.add(options);
+        forkResult.waitKilled().catch(() => {}).finally(() => {
+            worker.forks.delete(options);
+        });
+        return forkResult;
     }
 
     async getClusterWorkers() {
@@ -26,6 +31,7 @@ export class ClusterFork {
         for (const worker of this.runtime.clusterWorkers) {
             ret[worker.peer.peerName] = {
                 labels: worker.labels,
+                forks: [...worker.forks],
             };
         }
         return ret;

package/src/services/plugin.ts

@@ -115,7 +115,6 @@ export class PluginComponent {
         return {
             pid: host?.worker?.pid,
             clientsCount: host?.io?.clientsCount,
-            stats: host?.stats,
             rpcObjects,
             packageJson,
             pendingResults,

package/dist/plugin/plugin-remote-stats.d.ts

@@ -1,7 +0,0 @@
-import { RuntimeWorker } from "./runtime/runtime-worker";
-export interface PluginStats {
-    type: 'stats';
-    cpuUsage: NodeJS.CpuUsage;
-    memoryUsage: NodeJS.MemoryUsage;
-}
-export declare function startStatsUpdater(allMemoryStats: Map<RuntimeWorker, NodeJS.MemoryUsage>, updateStats: (stats: PluginStats) => Promise<void>): void;

package/dist/plugin/plugin-remote-stats.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startStatsUpdater = startStatsUpdater;
-function startStatsUpdater(allMemoryStats, updateStats) {
-    if (!updateStats)
-        console.warn('wtf');
-    setInterval(() => {
-        let cpuUsage;
-        let memoryUsage;
-        if (process.cpuUsage)
-            cpuUsage = process.cpuUsage();
-        allMemoryStats.set(undefined, process.memoryUsage());
-        memoryUsage = {
-            rss: 0,
-            heapTotal: 0,
-            heapUsed: 0,
-            external: 0,
-            arrayBuffers: 0,
-        };
-        for (const mu of allMemoryStats.values()) {
-            if (!mu)
-                continue;
-            memoryUsage.rss += mu.rss;
-            memoryUsage.heapTotal += mu.heapTotal;
-            memoryUsage.heapUsed += mu.heapUsed;
-            memoryUsage.external += mu.external;
-            memoryUsage.arrayBuffers += mu.arrayBuffers;
-        }
-        updateStats({
-            type: 'stats',
-            cpuUsage,
-            memoryUsage,
-        }).catch(() => { });
-    }, 10000);
-}
-//# sourceMappingURL=plugin-remote-stats.js.map

package/dist/plugin/plugin-remote-stats.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-remote-stats.js","sourceRoot":"","sources":["../../src/plugin/plugin-remote-stats.ts"],"names":[],"mappings":";;AAQA,8CAmCC;AAnCD,SAAgB,iBAAiB,CAAC,cAAsD,EAAE,WAAkD;IACxI,IAAI,CAAC,WAAW;QACZ,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACvB,WAAW,CAAC,GAAG,EAAE;QACb,IAAI,QAAyB,CAAC;QAC9B,IAAI,WAA+B,CAAC;QACpC,IAAI,OAAO,CAAC,QAAQ;YAChB,QAAQ,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;QAElC,cAAc,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAErD,WAAW,GAAG;YACV,GAAG,EAAE,CAAC;YACN,SAAS,EAAE,CAAC;YACZ,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,CAAC;YACX,YAAY,EAAE,CAAC;SAClB,CAAA;QAED,KAAK,MAAM,EAAE,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;YACvC,IAAI,CAAC,EAAE;gBACH,SAAS;YACb,WAAW,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC;YAC1B,WAAW,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,CAAC;YACtC,WAAW,CAAC,QAAQ,IAAI,EAAE,CAAC,QAAQ,CAAC;YACpC,WAAW,CAAC,QAAQ,IAAI,EAAE,CAAC,QAAQ,CAAC;YACpC,WAAW,CAAC,YAAY,IAAI,EAAE,CAAC,YAAY,CAAC;QAChD,CAAC;QAED,WAAW,CAAC;YACR,IAAI,EAAE,OAAO;YACb,QAAQ;YACR,WAAW;SACd,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IACvB,CAAC,EAAE,KAAK,CAAC,CAAC;AACd,CAAC"}

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

@@ -1,44 +0,0 @@
-import { RuntimeWorker } from "./runtime/runtime-worker";
-
-export interface PluginStats {
-    type: 'stats',
-    cpuUsage: NodeJS.CpuUsage;
-    memoryUsage: NodeJS.MemoryUsage;
-}
-
-export function startStatsUpdater(allMemoryStats: Map<RuntimeWorker, NodeJS.MemoryUsage>, updateStats: (stats: PluginStats) => Promise<void>) {
-    if (!updateStats)
-        console.warn('wtf')
-    setInterval(() => {
-        let cpuUsage: NodeJS.CpuUsage;
-        let memoryUsage: NodeJS.MemoryUsage;
-        if (process.cpuUsage)
-            cpuUsage = process.cpuUsage();
-
-        allMemoryStats.set(undefined, process.memoryUsage());
-
-        memoryUsage = {
-            rss: 0,
-            heapTotal: 0,
-            heapUsed: 0,
-            external: 0,
-            arrayBuffers: 0,
-        }
-
-        for (const mu of allMemoryStats.values()) {
-            if (!mu)
-                continue;
-            memoryUsage.rss += mu.rss;
-            memoryUsage.heapTotal += mu.heapTotal;
-            memoryUsage.heapUsed += mu.heapUsed;
-            memoryUsage.external += mu.external;
-            memoryUsage.arrayBuffers += mu.arrayBuffers;
-        }
-
-        updateStats({
-            type: 'stats',
-            cpuUsage,
-            memoryUsage,
-        }).catch(() => {});
-    }, 10000);
-}