scoundrel-remote-eval 1.0.7 → 1.0.9

package/src/client/reference-proxy.js

@@ -1,29 +0,0 @@
-const proxyMethodSpawner = (reference, prop) => (...args) => reference.callMethodWithReference(prop, ...args)
-
-const proxyObjectHandler = {
-  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)
-  },
-
-  set(receiver, prop, newValue) {
-    throw new Error("set property isn't supported yet")
-
-    if (typeof receiver == "function") receiver = receiver()
-    if (!(prop in receiver)) throw new PropertyNotFoundError(`Property not found: ${prop}`)
-
-    return Reflect.set(receiver, prop, newValue)
-  }
-}
-
-const referenceProxy = (wrappedObject) => new Proxy(wrappedObject, proxyObjectHandler)
-
-export default referenceProxy

package/src/client/reference.js

@@ -1,67 +0,0 @@
-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/src/logger.js

@@ -1,56 +0,0 @@
-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)
-  }
-
-  _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/src/python-web-socket-runner.js

@@ -1,87 +0,0 @@
-import {exec, spawn} from "child_process"
-import Logger from "./logger.js"
-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, 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)
-  }
-
-  onProcessExit = () => {
-    if (this.pid) {
-      this.close()
-      logger.log(() => `onProcessExit: Killing Python process with PID ${this.pid}`)
-    }
-  }
-
-  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.error(() => `stderr: ${data}`)
-
-    if (this.waitForPidReject) {
-      this.waitForPidRejectError = new Error(`Python process stderr before PID was received: ${data}`)
-    }
-  }
-
-  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) {
-        this.waitForPidResolve()
-        this.waitForPidResolve = null
-        this.waitForPidReject = null
-        this.waitForPidRejectError = null
-      }
-    }
-  }
-
-  close() {
-    if (this.pid) {
-      exec(`kill ${this.pid}`)
-    }
-  }
-}

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

@@ -1,28 +0,0 @@
-export default class WebSocketClient {
-  constructor(ws) {
-    this.ws = ws
-
-    ws.on("error", this.onError)
-    ws.on("message", this.onMessage)
-  }
-
-  onCommand(callback) {
-    this.onCommandCallback = callback
-  }
-
-  onError = (error) => {
-    console.error("WebSocketClient error", error)
-  }
-
-  onMessage = (rawData) => {
-    const data = JSON.parse(rawData)
-
-    if (!this.onCommandCallback) throw new Error("Command callback hasn't been set")
-
-    this.onCommandCallback(data)
-  }
-
-  async send(data) {
-    await this.ws.send(JSON.stringify(data))
-  }
-}

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

@@ -1,22 +0,0 @@
-import WebSocketClient from "./client.js"
-
-export default class WebSocket {
-  constructor(webSocketServer) {
-    this.wss = webSocketServer
-    this.wss.on("connection", this.onConnection)
-  }
-
-  close() { this.wss.close() }
-
-  onConnection = (ws) => {
-    if (!this.onNewClientCallback) throw new Error("'onNewClient' hasn't been called")
-
-    this.onNewClientCallback(new WebSocketClient(ws))
-  }
-
-  onNewClient(callback) {
-    if (!callback) throw new Error("No callback was given")
-
-    this.onNewClientCallback = callback
-  }
-}

package/src/server/index.js

@@ -1,21 +0,0 @@
-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.events = new EventEmitter()
-  }
-
-  close() { this.backend.close() }
-  getClients() { return this.clients }
-
-  onNewClient = (clientBackend) => {
-    const client = new Client(clientBackend)
-
-    this.clients.push(client)
-    this.events.emit("newClient", client)
-  }
-}