scoundrel-remote-eval 1.0.8 → 1.0.10

package/build/client/index.js

@@ -0,0 +1,452 @@
+// @ts-check
+import Logger from "../logger.js";
+import Reference from "./reference.js";
+const logger = new Logger("Scoundrel Client");
+// logger.setDebug(true)
+export default class Client {
+    /**
+     * Creates a new Scoundrel Client
+     *
+     * @param {any} backend The backend connection (e.g., WebSocket)
+     * @param {{enableServerControl?: boolean}} [options]
+     */
+    constructor(backend, options = {}) {
+        /**
+         * Handles an incoming command from the backend
+         * @param {object} args
+         * @param {string} args.command
+         * @param {number} args.command_id
+         * @param {any} args.data
+         * @param {string} [args.error]
+         * @param {string} [args.errorStack]
+         */
+        this.onCommand = ({ command, command_id: commandID, data, error, errorStack, ...restArgs }) => {
+            logger.log(() => ["onCommand", { command, commandID, data, error, errorStack, restArgs }]);
+            try {
+                if (!command) {
+                    throw new Error(`No command key given in data: ${Object.keys(restArgs).join(", ")}`);
+                }
+                else if (command == "command_response") {
+                    if (!(commandID in this.outgoingCommands)) {
+                        throw new Error(`Outgoing command ${commandID} not found: ${Object.keys(this.outgoingCommands).join(", ")}`);
+                    }
+                    const savedCommand = this.outgoingCommands[commandID];
+                    delete this.outgoingCommands[commandID];
+                    if (error) {
+                        const errorToThrow = new Error(error);
+                        if (errorStack) {
+                            errorToThrow.stack = `${errorStack}\n\n${errorToThrow.stack}`;
+                        }
+                        savedCommand.reject(errorToThrow);
+                    }
+                    else {
+                        logger.log(() => [`Resolving command ${commandID} with data`, data]);
+                        savedCommand.resolve(data.data);
+                    }
+                }
+                else if (!this.serverControlEnabled) {
+                    this.send({ command: "command_response", command_id: commandID, error: "Server control is disabled" });
+                    return;
+                }
+                else if (command == "get_object") {
+                    const serverObject = this._getRegisteredObject(data.object_name);
+                    let object;
+                    if (serverObject) {
+                        object = serverObject;
+                    }
+                    else {
+                        object = globalThis[data.object_name];
+                        if (!object)
+                            throw new Error(`No such object: ${data.object_name}`);
+                    }
+                    const objectId = ++this.objectsCount;
+                    this.objects[objectId] = object;
+                    this.respondToCommand(commandID, { object_id: objectId });
+                }
+                else if (command == "new_object_with_reference") {
+                    const className = data.class_name;
+                    let object;
+                    if (typeof className == "string") {
+                        const ClassInstance = this.getClass(className) || globalThis[className];
+                        if (!ClassInstance)
+                            throw new Error(`No such class: ${className}`);
+                        object = new ClassInstance(...data.args);
+                    }
+                    else {
+                        throw new Error(`Don't know how to handle class name: ${typeof className}`);
+                    }
+                    const objectId = ++this.objectsCount;
+                    this.objects[objectId] = object;
+                    this.respondToCommand(commandID, { object_id: objectId });
+                }
+                else if (command == "call_method_on_reference") {
+                    const referenceId = data.reference_id;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    const method = object[data.method_name];
+                    if (!method)
+                        throw new Error(`No method called '${data.method_name}' on a '${object.constructor.name}'`);
+                    const response = method.call(object, ...data.args);
+                    if (data.with == "reference") {
+                        const objectId = ++this.objectsCount;
+                        this.objects[objectId] = response;
+                        this.respondToCommand(commandID, { response: objectId });
+                    }
+                    else {
+                        this.respondToCommand(commandID, { response });
+                    }
+                }
+                else if (command == "serialize_reference") {
+                    const referenceId = data.reference_id;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    this.respondToCommand(commandID, JSON.stringify(object));
+                }
+                else if (command == "read_attribute") {
+                    const attributeName = data.attribute_name;
+                    const referenceId = data.reference_id;
+                    const returnWith = data.with;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    const attribute = object[attributeName];
+                    if (returnWith == "reference") {
+                        const objectId = ++this.objectsCount;
+                        this.objects[objectId] = attribute;
+                        this.respondToCommand(commandID, { response: objectId });
+                    }
+                    else {
+                        this.respondToCommand(commandID, { response: attribute });
+                    }
+                }
+                else if (command == "eval") {
+                    const respondWithResult = (evalResult) => {
+                        if (data.with_reference) {
+                            const objectId = ++this.objectsCount;
+                            this.objects[objectId] = evalResult;
+                            this.respondToCommand(commandID, { object_id: objectId });
+                        }
+                        else {
+                            this.respondToCommand(commandID, { response: evalResult });
+                        }
+                    };
+                    const evalResult = eval(data.eval_string);
+                    if (evalResult && typeof evalResult.then == "function") {
+                        evalResult.then(respondWithResult).catch((promiseError) => {
+                            if (promiseError instanceof Error) {
+                                this.send({ command: "command_response", command_id: commandID, error: promiseError.message, errorStack: promiseError.stack });
+                            }
+                            else {
+                                this.send({ command: "command_response", command_id: commandID, error: String(promiseError) });
+                            }
+                        });
+                    }
+                    else {
+                        respondWithResult(evalResult);
+                    }
+                }
+                else {
+                    throw new Error(`Unknown command: ${command}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.send({ command: "command_response", command_id: commandID, error: error.message, errorStack: error.stack });
+                }
+                else {
+                    this.send({ command: "command_response", command_id: commandID, error: String(error) });
+                }
+                logger.error(error);
+            }
+        };
+        this.backend = backend;
+        this.backend.onCommand(this.onCommand);
+        /** @type {Record<number, any>} */
+        this.outgoingCommands = {};
+        this.incomingCommands = {};
+        this.outgoingCommandsCount = 0;
+        /** @type {Record<string, any>} */
+        this._classes = {};
+        /** @type {Record<string, any>} */
+        this._objects = {};
+        /** @type {Record<string, Reference>} */
+        this.references = {};
+        /** @type {Record<number, any>} */
+        this.objects = {};
+        this.objectsCount = 0;
+        /** @type {boolean} */
+        this.serverControlEnabled = Boolean(options.enableServerControl);
+    }
+    /**
+     * Closes the client connection
+     */
+    async close() {
+        this.backend.close();
+    }
+    /**
+     * Calls a method on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async callMethodOnReference(referenceId, methodName, ...args) {
+        const result = await this.sendCommand("call_method_on_reference", {
+            args: this.parseArg(args),
+            method_name: methodName,
+            reference_id: referenceId,
+            with: "result"
+        });
+        return result.response;
+    }
+    /**
+     * Calls a method on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {
+        const result = await this.sendCommand("call_method_on_reference", {
+            args: this.parseArg(args),
+            method_name: methodName,
+            reference_id: referenceId,
+            with: "reference"
+        });
+        const id = result.response;
+        return this.spawnReference(id);
+    }
+    /**
+     * Evaluates a string and returns a new reference
+     *
+     * @param {string} evalString
+     * @returns {Promise<Reference>}
+     */
+    async evalWithReference(evalString) {
+        const evalReference = await this.getObject("eval");
+        return await evalReference.callMethodWithReference("call", null, evalString);
+    }
+    /**
+     * Imports a module and returns a reference to it
+     *
+     * @param {string} importName
+     * @returns {Promise<Reference>}
+     */
+    async import(importName) {
+        const result = await this.sendCommand("import", {
+            import_name: importName
+        });
+        logger.log(() => ["import", { result }]);
+        if (!result)
+            throw new Error("No result given");
+        if (!result.object_id)
+            throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+        const id = result.object_id;
+        return this.spawnReference(id);
+    }
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {Promise<Reference>}
+     */
+    async getObject(objectName) {
+        const result = await this.sendCommand("get_object", {
+            object_name: objectName
+        });
+        if (!result)
+            throw new Error("Blank result given");
+        const id = result.object_id;
+        return this.spawnReference(id);
+    }
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} className
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    async newObjectWithReference(className, ...args) {
+        const result = await this.sendCommand("new_object_with_reference", {
+            args: this.parseArg(args),
+            class_name: className
+        });
+        if (!result)
+            throw new Error("Blank result given");
+        const id = result.object_id;
+        if (!id)
+            throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+        return this.spawnReference(id);
+    }
+    /**
+     * Checks if the input is a plain object
+     * @param {any} input
+     * @returns {boolean}
+     */
+    isPlainObject(input) {
+        if (input && typeof input === "object" && !Array.isArray(input)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Parases an argument for sending to the server
+     *
+     * @param {any} arg
+     * @returns {any}
+     */
+    parseArg(arg) {
+        if (Array.isArray(arg)) {
+            return arg.map((argInArray) => this.parseArg(argInArray));
+        }
+        else if (arg instanceof Reference) {
+            return {
+                __scoundrel_object_id: arg.id,
+                __scoundrel_type: "reference"
+            };
+        }
+        else if (this.isPlainObject(arg)) {
+            /** @type {Record<any, any>} */
+            const newObject = {};
+            for (const key in arg) {
+                const value = arg[key];
+                newObject[key] = this.parseArg(value);
+            }
+            return newObject;
+        }
+        return arg;
+    }
+    /**
+     * Reads an attribute on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<Reference>}
+     */
+    async readAttributeOnReferenceWithReference(referenceId, attributeName) {
+        const result = await this.sendCommand("read_attribute", {
+            attribute_name: attributeName,
+            reference_id: referenceId,
+            with: "reference"
+        });
+        const id = result.response;
+        return this.spawnReference(id);
+    }
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<any>}
+     */
+    async readAttributeOnReference(referenceId, attributeName) {
+        const result = await this.sendCommand("read_attribute", {
+            attribute_name: attributeName,
+            reference_id: referenceId,
+            with: "result"
+        });
+        return result.response;
+    }
+    /**
+     * Registers a class by name
+     *
+     * @param {string} className
+     * @param {any} classInstance
+     */
+    registerClass(className, classInstance) {
+        if (className in this._classes)
+            throw new Error(`Class already exists: ${className}`);
+        this._classes[className] = classInstance;
+    }
+    /**
+     * Gets a registered class by name
+     *
+     * @param {string} className
+     * @returns {any}
+     */
+    getClass(className) {
+        return this._classes[className];
+    }
+    /**
+     * Registers an object by name
+     *
+     * @param {string} objectName
+     * @param {any} objectInstance
+     */
+    registerObject(objectName, objectInstance) {
+        if (objectName in this._objects)
+            throw new Error(`Object already exists: ${objectName}`);
+        this._objects[objectName] = objectInstance;
+    }
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {any}
+     */
+    _getRegisteredObject(objectName) {
+        return this._objects[objectName];
+    }
+    /**
+     * Responds to a command from the backend
+     * @param {number} commandId
+     * @param {any} data
+     */
+    respondToCommand(commandId, data) {
+        this.sendCommand("command_response", { command_id: commandId, data });
+    }
+    /**
+     * Sends a command to the backend and returns a promise that resolves with the response
+     * @param {string} command
+     * @param {any} data
+     * @returns {Promise<any>}
+     */
+    sendCommand(command, data) {
+        return new Promise((resolve, reject) => {
+            const outgoingCommandCount = ++this.outgoingCommandsCount;
+            const commandData = {
+                command,
+                command_id: outgoingCommandCount,
+                data
+            };
+            this.outgoingCommands[outgoingCommandCount] = { resolve, reject };
+            logger.log(() => ["Sending", commandData]);
+            this.send(commandData);
+        });
+    }
+    /**
+     * Sends data to the backend
+     * @param {any} data
+     */
+    send(data) {
+        this.backend.send(data);
+    }
+    /**
+     * Serializes a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @returns {Promise<any>}
+     */
+    async serializeReference(referenceId) {
+        const json = await this.sendCommand("serialize_reference", { reference_id: referenceId });
+        return JSON.parse(json);
+    }
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} id
+     * @returns {Reference}
+     */
+    spawnReference(id) {
+        const reference = new Reference(this, id);
+        this.references[id] = reference;
+        return reference;
+    }
+    enableServerControl() {
+        this.serverControlEnabled = true;
+    }
+}

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":";AAyCA;;;GAGG;AACH,+CAHW,GAAG,oBAGwE"}

package/build/client/reference-proxy.js

@@ -0,0 +1,41 @@
+// @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) {
+        void receiver;
+        void prop;
+        void newValue;
+        throw new Error("set property isn't supported yet");
+    }
+};
+/**
+ * @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"}