scoundrel-remote-eval 1.0.5 → 1.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "scoundrel-remote-eval",
   "type": "module",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "",
   "main": "src/index.js",
   "scripts": {

package/spec/reference-with-proxy-spec.js

@@ -19,6 +19,12 @@ describe("referenceWithProxy", () => {
     await shared.clientWebSocket.waitForOpened()
 
     shared.client = new Client(shared.clientWebSocket)
+
+    shared.serverClient = shared.server.getClients()[0]
+
+    if (!shared.serverClient) {
+      throw new Error("No client connected to server")
+    }
   })
 
   afterEach(async () => {
@@ -54,4 +60,28 @@ describe("referenceWithProxy", () => {
     expect(firstValue).toEqual("test1")
     expect(secondValue).toEqual("test2")
   })
+
+  it("calls methods", async () => {
+    const stringObjectReference = await shared.client.newObjectWithReference("Array")
+    const stringObject = referenceWithProxy(stringObjectReference)
+
+    await stringObject.push("test1")
+    await stringObject.push("test2")
+
+    const result = await stringObject.__serialize()
+
+    expect(result).toEqual(["test1", "test2"])
+  })
+
+  it("calls methods on the client from the server", async () => {
+    const stringObjectReference = await shared.serverClient.newObjectWithReference("Array")
+    const stringObject = referenceWithProxy(stringObjectReference)
+
+    await stringObject.push("test1")
+    await stringObject.push("test2")
+
+    const result = await stringObject.__serialize()
+
+    expect(result).toEqual(["test1", "test2"])
+  })
 })

package/spec/web-socket-javascript-spec.js

@@ -46,4 +46,19 @@ describe("scoundrel - web-socket - javascript", () => {
 
     expect(result).toEqual("test1, test2")
   })
+
+  it("handles errors from method calls", async () => {
+    const stringObject = await shared.client.newObjectWithReference("Array")
+
+    let caughtError = null
+
+    try {
+      await stringObject.callMethod("nonExistentMethod")
+    } catch (error) {
+      caughtError = error
+    }
+
+    expect(caughtError).toBeInstanceOf(Error)
+    expect(caughtError.message).toEqual("No method called 'nonExistentMethod' on a 'Array'")
+  })
 })

package/spec/web-socket-python-spec.js

@@ -1,21 +1,30 @@
 import Client from "../src/client/index.js"
 import ClientWebSocket from "../src/client/connections/web-socket/index.js"
+import Logger from "../src/logger.js"
 import PythonWebSocketRunner from "../src/python-web-socket-runner.js"
 import {WebSocket} from "ws"
 
 const shared = {}
+const logger = new Logger("Scoundrel WebSocket Python Spec")
 
 describe("scoundrel - web-socket - python", () => {
   beforeEach(async () => {
+    logger.log("Starting Python with client")
     shared.pythonWebSocketRunner = new PythonWebSocketRunner()
 
+    logger.log("Running Python WebSocket runner and waiting for PID")
     await shared.pythonWebSocketRunner.runAndWaitForPid()
 
+    logger.log("Starting WebSocket client connection")
     const ws = new WebSocket("ws://localhost:53874")
+
+    logger.log("Creating ClientWebSocket")
     const clientWebSocket = new ClientWebSocket(ws)
 
+    logger.log("Waiting for WebSocket to open")
     await clientWebSocket.waitForOpened()
 
+    logger.log("Creating Scoundrel Client")
     shared.client = new Client(clientWebSocket)
   })
 

package/src/client/connections/web-socket/index.js

@@ -19,45 +19,29 @@ export default class WebSocket {
     await this.ws.close()
   }
 
+  onCommand(callback) {
+    this.onCommandCallback = callback
+  }
+
   onSocketError = (event) => {
     logger.error(() => ["onSocketError", event])
   }
 
   onSocketMessage = (event) => {
     const data = JSON.parse(event.data)
-    const commandId = data.command_id
-
-    if (!(commandId in this.commands)) throw new Error(`Command ${commandId} not found`)
-
-    const command = this.commands[commandId]
 
-    delete this.commands[commandId]
-
-    if (data.error) {
-      command.reject(new Error(data.error))
-    } else {
-      command.resolve(data.data)
-    }
+    logger.log(() => ["Client::Connections::WebSocket onSocketMessage", data])
+    this.onCommandCallback(data)
   }
 
-  onSocketOpen = (event) => {
-    logger.log(() =>"onSocketOpen")
+  onSocketOpen = (_event) => {
+    logger.log("onSocketOpen")
   }
 
   send(data) {
-    return new Promise((resolve, reject) => {
-      const commandCount = ++this.commandsCount
-      const sendData = JSON.stringify({
-        command_id: commandCount,
-        data
-      })
-
-      this.commands[commandCount] = {resolve, reject}
-
-      logger.log(() => ["Sending", sendData])
-
-      this.ws.send(sendData)
-    })
+    const sendData = JSON.stringify(data)
+    logger.log(() => ["Sending", sendData])
+    this.ws.send(sendData)
   }
 
   waitForOpened = () => new Promise((resolve, reject) => {

package/src/client/index.js

@@ -6,19 +6,44 @@ 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)
+   */
   constructor(backend) {
     this.backend = backend
+    this.backend.onCommand(this.onCommand)
+
+    this.outgoingCommands = {}
+    this.incomingCommands = {}
+    this.outgoingCommandsCount = 0
+
+    this._classes = {}
+    this._objects = {}
     this.references = {}
+    this.objects = {}
+    this.objectsCount = 0
   }
 
+  /**
+   * 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.backend.send({
+    const result = await this.sendCommand("call_method_on_reference", {
       args: this.parseArg(args),
-      command: "call_method_on_reference",
       method_name: methodName,
       reference_id: referenceId,
       with: "result"
@@ -27,10 +52,17 @@ export default class Client {
     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.backend.send({
+    const result = await this.sendCommand("call_method_on_reference", {
       args: this.parseArg(args),
-      command: "call_method_on_reference",
       method_name: methodName,
       reference_id: referenceId,
       with: "reference"
@@ -40,9 +72,14 @@ export default class Client {
     return this.spawnReference(id)
   }
 
+  /**
+   * Evaluates a string and returns a new reference
+   *
+   * @param {string} evalString
+   * @returns {Promise<Reference>}
+   */
   async evalWithReference(evalString) {
-    const result = await this.backend.send({
-      command: "eval",
+    const result = await this.sendCommand("eval", {
       eval_string: evalString,
       with_reference: true
     })
@@ -51,22 +88,35 @@ export default class Client {
     return this.spawnReference(id)
   }
 
+  /**
+   * Imports a module and returns a reference to it
+   *
+   * @param {string} importName
+   * @returns {Promise<Reference>}
+   */
   async import(importName) {
-    const result = await this.backend.send({
-      command: "import",
+    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.backend.send({
-      command: "get_object",
+    const result = await this.sendCommand("get_object", {
       object_name: objectName
     })
 
@@ -77,10 +127,15 @@ export default class Client {
     return this.spawnReference(id)
   }
 
+  /**
+   * Spawns a new reference to an object
+   *
+   * @param {string} id
+   * @returns {Promise<Reference>}
+   */
   async newObjectWithReference(className, ...args) {
-    const result = await this.backend.send({
+    const result = await this.sendCommand("new_object_with_reference", {
       args: this.parseArg(args),
-      command: "new_object_with_reference",
       class_name: className
     })
 
@@ -88,6 +143,8 @@ export default class Client {
 
     const id = result.object_id
 
+    if (!id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)
+
     return this.spawnReference(id)
   }
 
@@ -99,6 +156,121 @@ export default class Client {
     return false
   }
 
+  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 == "get_object") {
+        const serverObject = this._getRegisteredObject(data.object_name)
+        let object
+
+        if (serverObject) {
+          object = serverObject
+        } else {
+          object = global[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) || global[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)
+
+        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 == "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 {
+        throw new Error(`Unknown command: ${command}`)
+      }
+    } catch (error) {
+      this.send({command: "command_response", command_id: commandID, error: error.message, errorStack: error.stack})
+
+      logger.error(error)
+    }
+  }
+
+  /**
+   * 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))
@@ -122,9 +294,15 @@ export default class Client {
     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.backend.send({
-      command: "read_attribute",
+    const result = await this.sendCommand("read_attribute", {
       attribute_name: attributeName,
       reference_id: referenceId,
       with: "reference"
@@ -134,9 +312,15 @@ export default class Client {
     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.backend.send({
-      command: "read_attribute",
+    const result = await this.sendCommand("read_attribute", {
       attribute_name: attributeName,
       reference_id: referenceId,
       with: "result"
@@ -144,12 +328,91 @@ export default class Client {
     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]
+  }
+
+  respondToCommand(commandId, data) {
+    this.sendCommand("command_response", {command_id: commandId, data})
+  }
+
+  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)
+    })
+  }
+
+  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.backend.send({command: "serialize_reference", reference_id: 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 {Promise<Reference>}
+   */
   spawnReference(id) {
     const reference = new Reference(this, id)
 

package/src/client/reference.js

@@ -1,4 +1,10 @@
 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
@@ -6,22 +12,55 @@ export default class Reference {
     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/src/logger.js

@@ -1,17 +1,37 @@
 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)
   }

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

@@ -4,14 +4,17 @@ import {realpath} from "node:fs/promises"
 
 const logger = new Logger("Scoundrel PythonWebSocketRunner")
 
+// logger.setDebug(true)
+
 export default class PythonWebSocketRunner {
   constructor() {
     process.on("exit", this.onProcessExit)
   }
 
   runAndWaitForPid() {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       this.waitForPidResolve = resolve
+      this.waitForPidReject = reject
       this.run()
     })
   }
@@ -20,6 +23,8 @@ export default class PythonWebSocketRunner {
     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)
   }
@@ -31,8 +36,28 @@ export default class PythonWebSocketRunner {
     }
   }
 
+  onChildExit = (code, signal) => {
+    logger.log(() => `Child process exited with code ${code} and signal ${signal}`)
+
+    if (this.waitForPidRejectError) {
+      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
+    }
+  }
+
   onChildStderr = (data) => {
-    logger.log(() => `stderr: ${data}`)
+    logger.error(() => `stderr: ${data}`)
+
+    if (this.waitForPidReject) {
+      this.waitForPidRejectError = new Error(`Python process stderr before PID was received: ${data}`)
+    }
   }
 
   onChildStdout = (data) => {
@@ -47,7 +72,9 @@ export default class PythonWebSocketRunner {
 
       if (this.waitForPidResolve) {
         this.waitForPidResolve()
-        this.waitForPidResolve = undefined
+        this.waitForPidResolve = null
+        this.waitForPidReject = null
+        this.waitForPidRejectError = null
       }
     }
   }

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

@@ -19,7 +19,7 @@ export default class WebSocketClient {
 
     if (!this.onCommandCallback) throw new Error("Command callback hasn't been set")
 
-    this.onCommandCallback(data.command_id, data.data)
+    this.onCommandCallback(data)
   }
 
   async send(data) {

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

@@ -6,7 +6,7 @@ export default class WebSocket {
     this.wss.on("connection", this.onConnection)
   }
 
-  close = () => this.wss.close()
+  close() { this.wss.close() }
 
   onConnection = (ws) => {
     if (!this.onNewClientCallback) throw new Error("'onNewClient' hasn't been called")
@@ -14,7 +14,7 @@ export default class WebSocket {
     this.onNewClientCallback(new WebSocketClient(ws))
   }
 
-  onNewClient = (callback) => {
+  onNewClient(callback) {
     if (!callback) throw new Error("No callback was given")
 
     this.onNewClientCallback = callback

package/src/server/index.js

@@ -1,39 +1,21 @@
-import Client from "./client/index.js"
+import Client from "../client/index.js"
+import EventEmitter from "events"
 
 export default class ScoundrelServer {
   constructor(backend) {
     this.backend = backend
     this.backend.onNewClient(this.onNewClient)
     this.clients = []
-    this._classes = {}
-    this._objects = {}
+    this.events = new EventEmitter()
   }
 
   close() { this.backend.close() }
+  getClients() { return this.clients }
 
   onNewClient = (clientBackend) => {
-    const client = new Client(clientBackend, this)
+    const client = new Client(clientBackend)
 
     this.clients.push(client)
-  }
-
-  registerClass(className, classInstance) {
-    if (className in this._classes) throw new Error(`Class already exists: ${className}`)
-
-    this._classes[className] = classInstance
-  }
-
-  registerObject(objectName, objectInstance) {
-    if (objectName in this._objects) throw new Error(`Object already exists: ${objectName}`)
-
-    this._objects[objectName] = objectInstance
-  }
-
-  getClass(className) {
-    return this._classes[className]
-  }
-
-  getObject(objectName) {
-    return this._objects[objectName]
+    this.events.emit("newClient", client)
   }
 }

package/src/server/client/index.js

@@ -1,103 +0,0 @@
-export default class ServerClient {
-  constructor(clientBackend, server) {
-    this.clientBackend = clientBackend
-    this.clientBackend.onCommand(this.onCommand)
-    this.objects = {}
-    this.objectsCount = 0
-    this.server = server
-  }
-
-  onCommand = (commandId, data) => {
-    try {
-      if (data.command == "get_object") {
-        const serverObject = this.server.getObject(data.object_name)
-        let object
-
-        if (serverObject) {
-          object = serverObject
-        } else {
-          object = global[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 (data.command == "new_object_with_reference") {
-        const className = data.class_name
-        let object
-
-        if (typeof className == "string") {
-          const ServerClassInstance = this.server.getClass(className)
-
-          if (ServerClassInstance) {
-            object = new ServerClassInstance(...data.args)
-          } else {
-            const classInstance = global[className]
-
-            if (!classInstance) throw new Error(`No such class: ${className}`)
-
-            object = new global[className](...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 (data.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)
-
-        this.respondToCommand(commandId, {response})
-      } else if (data.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 (data.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 {
-        this.clientBackend.send({type: "command_response", command_id: commandId, error: `Unknown command: ${data.command}`})
-      }
-    } catch (error) {
-      this.clientBackend.send({type: "command_response", command_id: commandId, error: `Unknown command: ${error.message}`})
-
-      console.error(error)
-    }
-  }
-
-  respondToCommand(commandId, data) {
-    this.clientBackend.send({type: "command_response", command_id: commandId, data})
-  }
-}