scoundrel-remote-eval 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "scoundrel-remote-eval",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jasmine"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaspernj/scoundrel.git"
+  },
+  "keywords": [
+    "scoundrel"
+  ],
+  "author": "kasper@diestoeckels.de",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/kaspernj/scoundrel/issues"
+  },
+  "homepage": "https://github.com/kaspernj/scoundrel#readme",
+  "devDependencies": {
+    "jasmine": "^5.1.0"
+  },
+  "dependencies": {
+    "ws": "^8.14.2"
+  }
+}

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

@@ -0,0 +1,40 @@
+import Client from "../src/client/index.js"
+import ClientWebSocket from "../src/client/connections/web-socket/index.js"
+import referenceWithProxy from "../src/client/reference-proxy.js"
+import Server from "../src/server/index.js"
+import ServerWebSocket from "../src/server/connections/web-socket/index.js"
+import {WebSocket, WebSocketServer} from "ws"
+
+const shared = {}
+
+describe("referenceWithProxy", () => {
+  beforeEach(async () => {
+    shared.wss = new WebSocketServer({port: 8080})
+    shared.serverWebSocket = new ServerWebSocket(shared.wss)
+    shared.server = new Server(shared.serverWebSocket)
+
+    shared.ws = new WebSocket("http://localhost:8080")
+    shared.clientWebSocket = new ClientWebSocket(shared.ws)
+
+    await shared.clientWebSocket.waitForOpened()
+
+    shared.client = new Client(shared.clientWebSocket)
+  })
+
+  afterEach(async () => {
+    await shared.client.close()
+    await shared.server.close()
+  })
+
+  it("creates a reference with a proxy", 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"])
+  })
+})

package/spec/support/jasmine.json

@@ -0,0 +1,13 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "**/*[sS]pec.?(m)js"
+  ],
+  "helpers": [
+    "helpers/**/*.?(m)js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true
+  }
+}

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

@@ -0,0 +1,38 @@
+import Client from "../src/client/index.js"
+import ClientWebSocket from "../src/client/connections/web-socket/index.js"
+import Server from "../src/server/index.js"
+import ServerWebSocket from "../src/server/connections/web-socket/index.js"
+import {WebSocket, WebSocketServer} from "ws"
+
+const shared = {}
+
+describe("scoundrel - web-socket - javascript", () => {
+  beforeEach(async () => {
+    shared.wss = new WebSocketServer({port: 8080})
+    shared.serverWebSocket = new ServerWebSocket(shared.wss)
+    shared.server = new Server(shared.serverWebSocket)
+
+    shared.ws = new WebSocket("http://localhost:8080")
+    shared.clientWebSocket = new ClientWebSocket(shared.ws)
+
+    await shared.clientWebSocket.waitForOpened()
+
+    shared.client = new Client(shared.clientWebSocket)
+  })
+
+  afterEach(async () => {
+    await shared.client.close()
+    await shared.server.close()
+  })
+
+  it("creates a server and connects to it with the client", async () => {
+    const stringObject = await shared.client.newObjectWithReference("Array")
+
+    await stringObject.callMethod("push", "test1")
+    await stringObject.callMethod("push", "test2")
+
+    const result = await stringObject.serialize()
+
+    expect(result).toEqual(["test1", "test2"])
+  })
+})

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

@@ -0,0 +1,46 @@
+import Client from "../src/client/index.js"
+import ClientWebSocket from "../src/client/connections/web-socket/index.js"
+import PythonWebSocketRunner from "../src/python-web-socket-runner.js"
+import {WebSocket} from "ws"
+
+const shared = {}
+
+describe("scoundrel - web-socket - python", () => {
+  beforeEach(async () => {
+    shared.pythonWebSocketRunner = new PythonWebSocketRunner()
+
+    await shared.pythonWebSocketRunner.runAndWaitForPid()
+
+    const ws = new WebSocket("ws://localhost:53874")
+    const clientWebSocket = new ClientWebSocket(ws)
+
+    await clientWebSocket.waitForOpened()
+
+    shared.client = new Client(clientWebSocket)
+  })
+
+  afterEach(async () => {
+    shared.client?.close()
+    shared.pythonWebSocketRunner?.close()
+  })
+
+  it("creates a server and connects to it with the client", async () => {
+    const stringObject = await shared.client.newObjectWithReference("[]")
+
+    await stringObject.callMethod("append", "test1")
+    await stringObject.callMethod("append", "test2")
+
+    const result = await stringObject.serialize()
+
+    expect(result).toEqual(["test1", "test2"])
+  })
+
+  it("imports classes and uses them", async () => {
+    const math = await shared.client.import("math")
+    const pi = await math.readAttributeWithReference("pi")
+    const cosOfPi = await math.callMethodWithReference("cos", pi)
+    const result = await cosOfPi.serialize()
+
+    expect(result).toEqual(-1)
+  })
+})

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

@@ -0,0 +1,67 @@
+import Logger from "../../../logger.js"
+
+const logger = new Logger("Scoundrel WebSocket")
+
+// logger.setDebug(true)
+
+export default class WebSocket {
+  constructor(ws) {
+    this.ws = ws
+    this.ws.addEventListener("error", this.onSocketError)
+    this.ws.addEventListener("open", this.onSocketOpen)
+    this.ws.addEventListener("message", this.onSocketMessage)
+
+    this.commands = {}
+    this.commandsCount = 0
+  }
+
+  async close() {
+    await this.ws.close()
+  }
+
+  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)
+    }
+  }
+
+  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)
+    })
+  }
+
+  waitForOpened = () => new Promise((resolve, reject) => {
+    this.ws.addEventListener("open", resolve)
+    this.ws.addEventListener("error", reject)
+  })
+}

package/src/client/index.js

@@ -0,0 +1,135 @@
+import Logger from "../logger.js"
+import Reference from "./reference.js"
+
+const logger = new Logger("Scoundrel Client")
+
+// logger.setDebug(true)
+
+export default class Client {
+  constructor(backend) {
+    this.backend = backend
+    this.references = {}
+  }
+
+  async close() {
+    this.backend.close()
+  }
+
+  async callMethodOnReference(referenceId, methodName, ...args) {
+    return await this.backend.send({
+      args: this.parseArg(args),
+      command: "call_method_on_reference",
+      method_name: methodName,
+      reference_id: referenceId,
+      with: "result"
+    })
+  }
+
+  async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {
+    const result = await this.backend.send({
+      args: this.parseArg(args),
+      command: "call_method_on_reference",
+      method_name: methodName,
+      reference_id: referenceId,
+      with: "reference"
+    })
+    const id = result.response
+
+    return this.spawnReference(id)
+  }
+
+  async evalWithReference(evalString) {
+    const result = await this.backend.send({
+      command: "eval",
+      eval_string: evalString,
+      with_reference: true
+    })
+    const id = result.object_id
+
+    return this.spawnReference(id)
+  }
+
+  async import(importName) {
+    const result = await this.backend.send({
+      command: "import",
+      import_name: importName
+    })
+
+    logger.log(() => ["import", {result}])
+
+    const id = result.object_id
+
+    return this.spawnReference(id)
+  }
+
+  async newObjectWithReference(className, ...args) {
+    const result = await this.backend.send({
+      args: this.parseArg(args),
+      command: "new_object_with_reference",
+      class_name: className
+    })
+
+    if (!result) throw new Error("Blank result given")
+
+    const id = result.object_id
+
+    return this.spawnReference(id)
+  }
+
+  isPlainObject = (input) => {
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+      return true
+    }
+
+    return false
+  }
+
+  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)) {
+      const newObject = {}
+
+      for (const key in arg) {
+        const value = arg[key]
+
+        newObject[key] = this.parseArg(value)
+      }
+
+      return newObject
+    }
+
+    return arg
+  }
+
+  async readAttributeOnReferenceWithReference(referenceId, attributeName) {
+    const result = await this.backend.send({
+      command: "read_attribute",
+      attribute_name: attributeName,
+      reference_id: referenceId,
+      with: "reference"
+    })
+    const id = result.response
+
+    return this.spawnReference(id)
+  }
+
+  async serializeReference(referenceId) {
+    const json = await this.backend.send({command: "serialize_reference", reference_id: referenceId})
+
+    return JSON.parse(json)
+  }
+
+  spawnReference(id) {
+    const reference = new Reference(this, id)
+
+    this.references[id] = reference
+
+    return reference
+  }
+}

package/src/client/reference-proxy.js

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,24 @@
+export default class Reference {
+  constructor(client, id) {
+    this.client = client
+    this.id = id
+
+    if (!id) throw new Error(`Invalid ID given: ${id}`)
+  }
+
+  async callMethod(methodName, ...args) {
+    return await this.client.callMethodOnReference(this.id, methodName, ...args)
+  }
+
+  async callMethodWithReference(methodName, ...args) {
+    return await this.client.callMethodOnReferenceWithReference(this.id, methodName, ...args)
+  }
+
+  async readAttributeWithReference(attributeName, ...args) {
+    return await this.client.readAttributeOnReferenceWithReference(this.id, attributeName, ...args)
+  }
+
+  async serialize() {
+    return await this.client.serializeReference(this.id)
+  }
+}

package/src/logger.js

@@ -0,0 +1,28 @@
+export default class Logger {
+  constructor(scopeName) {
+    this.debug = false
+    this.scopeName = scopeName
+  }
+
+  setDebug(newValue) {
+    this.debug = newValue
+  }
+
+  log(...args) {
+    if (!this.debug) {
+      return
+    }
+
+    if (args.length == 1 && typeof args[0] == "function") {
+      const callbackArgs = args[0]()
+
+      if (Array.isArray(callbackArgs)) {
+        console.log(this.scopeName, ...callbackArgs)
+      } else {
+        console.log(this.scopeName, callbackArgs)
+      }
+    } else {
+      console.log(this.scopeName, ...args)
+    }
+  }
+}

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

@@ -0,0 +1,60 @@
+import {exec, spawn} from "child_process"
+import Logger from "./logger.js"
+import {realpath} from "node:fs/promises"
+
+const logger = new Logger("Scoundrel PythonWebSocketRunner")
+
+export default class PythonWebSocketRunner {
+  constructor() {
+    process.on("exit", this.onProcessExit)
+  }
+
+  runAndWaitForPid() {
+    return new Promise((resolve) => {
+      this.waitForPidResolve = resolve
+      this.run()
+    })
+  }
+
+  async run() {
+    const filePath = `${process.cwd()}/../python/server/web-socket.py`
+    const fileRealPath = await realpath(filePath)
+    const child = spawn("python3", [fileRealPath])
+    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}`)
+    }
+  }
+
+  onChildStderr = (data) => {
+    logger.log(() => `stderr: ${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 = undefined
+      }
+    }
+  }
+
+  close() {
+    if (this.pid) {
+      exec(`kill ${this.pid}`)
+    }
+  }
+}

package/src/server/client/index.js

@@ -0,0 +1,62 @@
+export default class ServerClient {
+  constructor(clientBackend) {
+    this.clientBackend = clientBackend
+    this.clientBackend.onCommand(this.onCommand)
+    this.objects = {}
+    this.objectsCount = 0
+  }
+
+  onCommand = (commandId, data) => {
+    try {
+      if (data.command == "new_object_with_reference") {
+        const className = data.class_name
+        const objectId = ++this.objectsCount
+        let object
+
+        if (typeof className == "string") {
+          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}`)
+        }
+
+        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 {
+        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})
+  }
+}

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

@@ -0,0 +1,28 @@
+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.command_id, data.data)
+  }
+
+  async send(data) {
+    await this.ws.send(JSON.stringify(data))
+  }
+}

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,17 @@
+import Client from "./client/index.js"
+
+export default class ScoundrelServer {
+  constructor(backend) {
+    this.backend = backend
+    this.backend.onNewClient(this.onNewClient)
+    this.clients = []
+  }
+
+  close = () => this.backend.close()
+
+  onNewClient = (clientBackend) => {
+    const client = new Client(clientBackend)
+
+    this.clients.push(client)
+  }
+}