scoundrel-remote-eval 1.0.7 → 1.0.9

package/build/client/reference-proxy.d.ts

@@ -0,0 +1,7 @@
+export default referenceProxy;
+/**
+ * @param {any} wrappedObject
+ * @returns {Proxy}
+ */
+declare function referenceProxy(wrappedObject: any): ProxyConstructor;
+//# sourceMappingURL=reference-proxy.d.ts.map

package/build/client/reference-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-proxy.d.ts","sourceRoot":"","sources":["../../src/client/reference-proxy.js"],"names":[],"mappings":";AA8CA;;;GAGG;AACH,+CAHW,GAAG,oBAGwE"}

package/build/client/reference-proxy.js

@@ -0,0 +1,45 @@
+// @ts-check
+/**
+ * @param {import("./reference.js").default} reference
+ * @param {string} prop
+ * @returns {(...args: any[]) => Promise<any>}
+ */
+const proxyMethodSpawner = (reference, prop) => (...args) => reference.callMethodWithReference(prop, ...args);
+const proxyObjectHandler = {
+    /**
+     * @param {import("./reference.js").default|(() => import("./reference.js").default)} reference
+     * @param {string} prop
+     * @returns {any}
+     */
+    get(reference, prop) {
+        if (typeof reference == "function")
+            reference = reference();
+        if (prop == "__serialize") {
+            const method = reference.serialize;
+            const boundMethod = method.bind(reference);
+            return boundMethod;
+        }
+        return proxyMethodSpawner(reference, prop);
+    },
+    /**
+     * @param {import("./reference.js").default|(() => import("./reference.js").default)} receiver
+     * @param {string} prop
+     * @param {any} newValue
+     */
+    set(receiver, prop, newValue) {
+        throw new Error("set property isn't supported yet");
+        // @ts-expect-error
+        if (typeof receiver == "function")
+            receiver = receiver(); // eslint-disable-line no-unreachable
+        // @ts-expect-error
+        if (!(prop in receiver))
+            throw new PropertyNotFoundError(`Property not found: ${prop}`); // eslint-disable-line no-undef
+        return Reflect.set(receiver, prop, newValue);
+    }
+};
+/**
+ * @param {any} wrappedObject
+ * @returns {Proxy}
+ */
+const referenceProxy = (wrappedObject) => new Proxy(wrappedObject, proxyObjectHandler);
+export default referenceProxy;

package/build/client/reference.d.ts

@@ -0,0 +1,50 @@
+export default class Reference {
+    /**
+     * Creates a new Reference
+     *
+     * @param {any} client The client instance
+     * @param {string} id The reference ID
+     */
+    constructor(client: any, id: string);
+    client: any;
+    id: string;
+    /**
+     * Calls a method on the reference
+     *
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    callMethod(methodName: string, ...args: any[]): Promise<any>;
+    /**
+     * Calls a method on the reference using another reference as argument
+     *
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    callMethodWithReference(methodName: string, ...args: any[]): Promise<any>;
+    /**
+     * Reads an attribute from the reference
+     *
+     * @param {string} attributeName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    readAttribute(attributeName: string, ...args: any[]): Promise<any>;
+    /**
+     * Reads an attribute from the reference using another reference as argument
+     *
+     * @param {string} attributeName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    readAttributeWithReference(attributeName: string, ...args: any[]): Promise<any>;
+    /**
+     * Serializes the reference and returns the result directly
+     *
+     * @returns {Promise<any>}
+     */
+    serialize(): Promise<any>;
+}
+//# sourceMappingURL=reference.d.ts.map

package/build/client/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../src/client/reference.js"],"names":[],"mappings":"AAEA;IACE;;;;;OAKG;IACH,oBAHW,GAAG,MACH,MAAM,EAOhB;IAJC,YAAoB;IACpB,WAAY;IAKd;;;;;;OAMG;IACH,uBAJW,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;;;;OAMG;IACH,oCAJW,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;;OAIG;IACH,aAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;CACF"}

package/build/client/reference.js

@@ -0,0 +1,63 @@
+// @ts-check
+export default class Reference {
+    /**
+     * Creates a new Reference
+     *
+     * @param {any} client The client instance
+     * @param {string} id The reference ID
+     */
+    constructor(client, id) {
+        this.client = client;
+        this.id = id;
+        if (!id)
+            throw new Error(`Invalid ID given: ${id}`);
+    }
+    /**
+     * Calls a method on the reference
+     *
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async callMethod(methodName, ...args) {
+        return await this.client.callMethodOnReference(this.id, methodName, ...args);
+    }
+    /**
+     * Calls a method on the reference using another reference as argument
+     *
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async callMethodWithReference(methodName, ...args) {
+        return await this.client.callMethodOnReferenceWithReference(this.id, methodName, ...args);
+    }
+    /**
+     * Reads an attribute from the reference
+     *
+     * @param {string} attributeName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async readAttribute(attributeName, ...args) {
+        return await this.client.readAttributeOnReference(this.id, attributeName, ...args);
+    }
+    /**
+     * Reads an attribute from the reference using another reference as argument
+     *
+     * @param {string} attributeName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async readAttributeWithReference(attributeName, ...args) {
+        return await this.client.readAttributeOnReferenceWithReference(this.id, attributeName, ...args);
+    }
+    /**
+     * Serializes the reference and returns the result directly
+     *
+     * @returns {Promise<any>}
+     */
+    async serialize() {
+        return await this.client.serializeReference(this.id);
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/build/index.js

@@ -0,0 +1 @@
+export {};

package/build/logger.d.ts

@@ -0,0 +1,39 @@
+export default class Logger {
+    /**
+     * Creates a new Logger instance
+     *
+     * @param {string} scopeName The name of the scope for the logger
+     */
+    constructor(scopeName: string);
+    debug: boolean;
+    scopeName: string;
+    /**
+     * Enables or disables debug logging
+     *
+     * @param {boolean} newValue
+     */
+    setDebug(newValue: boolean): void;
+    /**
+     * Logs an error message to the console if debug is enabled
+     *
+     * @param  {...any} args
+     */
+    error(...args: any[]): void;
+    /**
+     * Logs a message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    log(...args: any[]): void;
+    /**
+     * Logs a warning message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    warn(...args: any[]): void;
+    /**
+     * Sends the log message to the console
+     * @param {string} logType
+     * @param  {...any} args
+     */
+    _sendToConsole(logType: string, ...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/build/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.js"],"names":[],"mappings":"AAEA;IACE;;;;OAIG;IACH,uBAFW,MAAM,EAKhB;IAFC,eAAkB;IAClB,kBAA0B;IAG5B;;;;OAIG;IACH,mBAFW,OAAO,QAIjB;IAED;;;;OAIG;IACH,eAFe,GAAG,EAAA,QAIjB;IAED;;;OAGG;IACH,aAFe,GAAG,EAAA,QAIjB;IAED;;;OAGG;IACH,cAFe,GAAG,EAAA,QAIjB;IAED;;;;OAIG;IACH,wBAHW,MAAM,WACF,GAAG,EAAA,QAkBjB;CACF"}

package/build/logger.js

@@ -0,0 +1,64 @@
+// @ts-check
+export default class Logger {
+    /**
+     * Creates a new Logger instance
+     *
+     * @param {string} scopeName The name of the scope for the logger
+     */
+    constructor(scopeName) {
+        this.debug = false;
+        this.scopeName = scopeName;
+    }
+    /**
+     * Enables or disables debug logging
+     *
+     * @param {boolean} newValue
+     */
+    setDebug(newValue) {
+        this.debug = newValue;
+    }
+    /**
+     * Logs an error message to the console if debug is enabled
+     *
+     * @param  {...any} args
+     */
+    error(...args) {
+        return this._sendToConsole("error", ...args);
+    }
+    /**
+     * Logs a message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    log(...args) {
+        return this._sendToConsole("log", ...args);
+    }
+    /**
+     * Logs a warning message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    warn(...args) {
+        return this._sendToConsole("warn", ...args);
+    }
+    /**
+     * Sends the log message to the console
+     * @param {string} logType
+     * @param  {...any} args
+     */
+    _sendToConsole(logType, ...args) {
+        if (!this.debug) {
+            return;
+        }
+        if (args.length == 1 && typeof args[0] == "function") {
+            const callbackArgs = args[0]();
+            if (Array.isArray(callbackArgs)) {
+                console[logType](this.scopeName, ...callbackArgs);
+            }
+            else {
+                console[logType](this.scopeName, callbackArgs);
+            }
+        }
+        else {
+            console[logType](this.scopeName, ...args);
+        }
+    }
+}

package/build/python-web-socket-runner.d.ts

@@ -0,0 +1,27 @@
+export default class PythonWebSocketRunner {
+    /** @type {Error | null} */
+    waitForPidRejectError: Error | null;
+    /** @type {((value: any) => void) | null} */
+    waitForPidResolve: ((value: any) => void) | null;
+    /** @type {((value: any) => void) | null} */
+    waitForPidReject: ((value: any) => void) | null;
+    runAndWaitForPid(): Promise<any>;
+    run(): Promise<void>;
+    onProcessExit: () => void;
+    /**
+     * @param {number} code
+     * @param {string} signal
+     */
+    onChildExit: (code: number, signal: string) => void;
+    /**
+     * @param {string | Buffer} data
+     */
+    onChildStderr: (data: string | Buffer) => void;
+    /**
+     * @param {string | Buffer} data
+     */
+    onChildStdout: (data: string | Buffer) => void;
+    pid: string;
+    close(): void;
+}
+//# sourceMappingURL=python-web-socket-runner.d.ts.map

package/build/python-web-socket-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-web-socket-runner.d.ts","sourceRoot":"","sources":["../src/python-web-socket-runner.js"],"names":[],"mappings":"AAUA;IACE,2BAA2B;IAC3B,uBADW,KAAK,GAAG,IAAI,CACK;IAE5B,4CAA4C;IAC5C,mBADW,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CAChB;IAExB,4CAA4C;IAC5C,kBADW,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CACjB;IAMvB,iCAMC;IAED,qBAQC;IAED,0BAKC;IAED;;;OAGG;IACH,cAAe,MAHJ,MAGQ,EAAE,QAFV,MAEgB,UAkB1B;IAED;;OAEG;IACH,gBAAiB,MAFN,MAAM,GAAG,MAEC,UAMpB;IAED;;OAEG;IACH,gBAAiB,MAFN,MAAM,GAAG,MAEC,UAqBpB;IAfG,YAAmB;IAiBvB,cAIC;CACF"}

package/build/python-web-socket-runner.js

@@ -0,0 +1,94 @@
+// @ts-check
+import { exec, spawn } from "child_process";
+import Logger from "./logger.js";
+import { realpath } from "fs/promises";
+const logger = new Logger("Scoundrel PythonWebSocketRunner");
+// logger.setDebug(true)
+export default class PythonWebSocketRunner {
+    constructor() {
+        /** @type {Error | null} */
+        this.waitForPidRejectError = null;
+        /** @type {((value: any) => void) | null} */
+        this.waitForPidResolve = null;
+        /** @type {((value: any) => void) | null} */
+        this.waitForPidReject = null;
+        this.onProcessExit = () => {
+            if (this.pid) {
+                this.close();
+                logger.log(() => `onProcessExit: Killing Python process with PID ${this.pid}`);
+            }
+        };
+        /**
+         * @param {number} code
+         * @param {string} signal
+         */
+        this.onChildExit = (code, signal) => {
+            logger.log(() => `Child process exited with code ${code} and signal ${signal}`);
+            if (this.waitForPidRejectError) {
+                if (!this.waitForPidReject) {
+                    throw new Error("waitForPidReject is undefined while waitForPidRejectError is set");
+                }
+                this.waitForPidReject(this.waitForPidRejectError);
+                this.waitForPidResolve = null;
+                this.waitForPidReject = null;
+                this.waitForPidRejectError = null;
+            }
+            else if (this.waitForPidReject) {
+                this.waitForPidReject(new Error(`Python process exited before PID was received (code: ${code}, signal: ${signal})`));
+                this.waitForPidResolve = null;
+                this.waitForPidReject = null;
+                this.waitForPidRejectError = null;
+            }
+        };
+        /**
+         * @param {string | Buffer} data
+         */
+        this.onChildStderr = (data) => {
+            logger.error(() => `stderr: ${data}`);
+            if (this.waitForPidReject) {
+                this.waitForPidRejectError = new Error(`Python process stderr before PID was received: ${data}`);
+            }
+        };
+        /**
+         * @param {string | Buffer} data
+         */
+        this.onChildStdout = (data) => {
+            logger.log(() => `stdout: ${data}`);
+            const match = (`${data}`).match(/^Started with PID (\d+) on (.+):(.+)\n$/);
+            if (match) {
+                this.pid = match[1];
+                logger.log(() => `Registered PID ${this.pid}`);
+                if (this.waitForPidResolve) {
+                    if (!this.waitForPidResolve) {
+                        throw new Error("waitForPidResolve is undefined while waitForPidRejectError is set");
+                    }
+                    this.waitForPidResolve(null);
+                    this.waitForPidResolve = null;
+                    this.waitForPidReject = null;
+                    this.waitForPidRejectError = null;
+                }
+            }
+        };
+        process.on("exit", this.onProcessExit);
+    }
+    runAndWaitForPid() {
+        return new Promise((resolve, reject) => {
+            this.waitForPidResolve = resolve;
+            this.waitForPidReject = reject;
+            this.run();
+        });
+    }
+    async run() {
+        const filePath = `${process.cwd()}/../python/server/web-socket.py`;
+        const fileRealPath = await realpath(filePath);
+        const child = spawn("python3", [fileRealPath]);
+        child.on("exit", this.onChildExit);
+        child.stdout.on("data", this.onChildStdout);
+        child.stderr.on("data", this.onChildStderr);
+    }
+    close() {
+        if (this.pid) {
+            exec(`kill ${this.pid}`);
+        }
+    }
+}

package/build/server/connections/web-socket/client.d.ts

@@ -0,0 +1,26 @@
+export default class WebSocketClient {
+    /**
+     * Creates a new WebSocketClient
+     * @param {import("ws").WebSocket} ws The WebSocket instance
+     */
+    constructor(ws: any);
+    ws: any;
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback: (data: any) => void): void;
+    onCommandCallback: (data: any) => void;
+    /**
+     * @param {Error} error
+     */
+    onError: (error: Error) => void;
+    /**
+     * @param {string} rawData
+     */
+    onMessage: (rawData: string) => void;
+    /**
+     * @param {any} data
+     */
+    send(data: any): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/build/server/connections/web-socket/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/server/connections/web-socket/client.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,qBAKC;IAJC,QAAY;IAMd;;OAEG;IACH,oBAFW,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,QAI7B;IADC,0BAHgB,GAAG,KAAK,IAAI,CAGK;IAGnC;;OAEG;IACH,UAAW,OAFA,KAEK,UAEf;IAED;;OAEG;IACH,YAAa,SAFF,MAES,UAMnB;IAED;;OAEG;IACH,WAFW,GAAG,iBAIb;CACF"}

package/build/server/connections/web-socket/client.js

@@ -0,0 +1,39 @@
+// @ts-check
+export default class WebSocketClient {
+    /**
+     * Creates a new WebSocketClient
+     * @param {import("ws").WebSocket} ws The WebSocket instance
+     */
+    constructor(ws) {
+        /**
+         * @param {Error} error
+         */
+        this.onError = (error) => {
+            console.error("WebSocketClient error", error);
+        };
+        /**
+         * @param {string} rawData
+         */
+        this.onMessage = (rawData) => {
+            const data = JSON.parse(rawData);
+            if (!this.onCommandCallback)
+                throw new Error("Command callback hasn't been set");
+            this.onCommandCallback(data);
+        };
+        this.ws = ws;
+        ws.on("error", this.onError);
+        ws.on("message", this.onMessage);
+    }
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback) {
+        this.onCommandCallback = callback;
+    }
+    /**
+     * @param {any} data
+     */
+    async send(data) {
+        await this.ws.send(JSON.stringify(data));
+    }
+}

package/build/server/connections/web-socket/index.d.ts

@@ -0,0 +1,19 @@
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {import("ws").Server} webSocketServer The WebSocket server instance
+     */
+    constructor(webSocketServer: any);
+    wss: any;
+    close(): void;
+    /**
+     * @param {import("ws").WebSocket} ws
+     */
+    onConnection: (ws: any) => void;
+    /**
+     * @param {(client: import("./client.js").default) => void} callback
+     */
+    onNewClient(callback: (client: import("./client.js").default) => void): void;
+    onNewClientCallback: (client: import("./client.js").default) => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/server/connections/web-socket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/connections/web-socket/index.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,kCAGC;IAFC,SAA0B;IAI5B,cAA4B;IAE5B;;OAEG;IACH,eAAgB,OAAE,UAIjB;IAED;;OAEG;IACH,sBAFW,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,OAAO,KAAK,IAAI,QAMzD;IADC,8BALkB,OAAO,aAAa,EAAE,OAAO,KAAK,IAAI,CAKrB;CAEtC"}

package/build/server/connections/web-socket/index.js

@@ -0,0 +1,29 @@
+// @ts-check
+import WebSocketClient from "./client.js";
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {import("ws").Server} webSocketServer The WebSocket server instance
+     */
+    constructor(webSocketServer) {
+        /**
+         * @param {import("ws").WebSocket} ws
+         */
+        this.onConnection = (ws) => {
+            if (!this.onNewClientCallback)
+                throw new Error("'onNewClient' hasn't been called");
+            this.onNewClientCallback(new WebSocketClient(ws));
+        };
+        this.wss = webSocketServer;
+        this.wss.on("connection", this.onConnection);
+    }
+    close() { this.wss.close(); }
+    /**
+     * @param {(client: import("./client.js").default) => void} callback
+     */
+    onNewClient(callback) {
+        if (!callback)
+            throw new Error("No callback was given");
+        this.onNewClientCallback = callback;
+    }
+}

package/build/server/index.d.ts

@@ -0,0 +1,20 @@
+export default class ScoundrelServer {
+    /**
+     * Creates a new Scoundrel server
+     * @param {import("./connections/web-socket/index.js").default} backend The backend connection handler
+     */
+    constructor(backend: import("./connections/web-socket/index.js").default);
+    backend: import("./connections/web-socket/index.js").default;
+    /** @type {Client[]} */
+    clients: Client[];
+    events: EventEmitter<any>;
+    close(): void;
+    getClients(): Client[];
+    /**
+     * @param {import("./connections/web-socket/client.js").default} clientBackend
+     */
+    onNewClient: (clientBackend: import("./connections/web-socket/client.js").default) => void;
+}
+import Client from "../client/index.js";
+import EventEmitter from "events";
+//# sourceMappingURL=index.d.ts.map

package/build/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH,qBAFW,OAAO,mCAAmC,EAAE,OAAO,EAU7D;IAPC,6DAAsB;IAGtB,uBAAuB;IACvB,SADW,MAAM,EAAE,CACF;IAEjB,0BAAgC;IAGlC,cAAgC;IAChC,uBAAoC;IAEpC;;OAEG;IACH,cAAe,eAFJ,OAAO,oCAAoC,EAAE,OAE5B,UAK3B;CACF;mBA9BkB,oBAAoB;yBACd,QAAQ"}

package/build/server/index.js

@@ -0,0 +1,26 @@
+// @ts-check
+import Client from "../client/index.js";
+import EventEmitter from "events";
+export default class ScoundrelServer {
+    /**
+     * Creates a new Scoundrel server
+     * @param {import("./connections/web-socket/index.js").default} backend The backend connection handler
+     */
+    constructor(backend) {
+        /**
+         * @param {import("./connections/web-socket/client.js").default} clientBackend
+         */
+        this.onNewClient = (clientBackend) => {
+            const client = new Client(clientBackend);
+            this.clients.push(client);
+            this.events.emit("newClient", client);
+        };
+        this.backend = backend;
+        this.backend.onNewClient(this.onNewClient);
+        /** @type {Client[]} */
+        this.clients = [];
+        this.events = new EventEmitter();
+    }
+    close() { this.backend.close(); }
+    getClients() { return this.clients; }
+}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "scoundrel-remote-eval",
   "type": "module",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "",
-  "main": "src/index.js",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": ["build/**"],
   "scripts": {
-    "test": "jasmine"
+    "build": "rm -rf build && tsc",
+    "lint": "eslint",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "jasmine",
+    "watch": "tsc -w"
   },
   "repository": {
     "type": "git",
@@ -21,7 +28,13 @@
   },
   "homepage": "https://github.com/kaspernj/scoundrel#readme",
   "devDependencies": {
-    "jasmine": "^5.1.0"
+    "@eslint/js": "^9.39.2",
+    "@types/jasmine": "^5.1.13",
+    "@types/node": "^25.0.2",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
+    "jasmine": "^5.1.0",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
     "ws": "^8.14.2"