websocket-text-relay 1.1.6 → 1.1.8

package/README.md

@@ -3,8 +3,6 @@
 This application connects to your text editor using the Language Server Protocol (LSP) and then starts a websocket
 server that front end clients can connect to and subscribe to file change events. This allows users to see their
 front end changes evaluated immediately as they type, without having to first save the file to disk or reload the browser.
-It's a similar concept to sites like CodePen and JsFiddle, except you can develop locally using your own text editor with all
-of your personalized plugins instead of having to use an in browser code editor.
 
 ## Usage
 
@@ -23,14 +21,14 @@ the status UI and verify everything is running by first starting up your text ed
 
 To use this on a professional level project that gives you the option to use modules, typescript, and react, I recommend using vite along with
 the plugin [vite-plugin-websocket-text-relay](https://github.com/niels4/vite-plugin-websocket-text-relay). This plugin gives you all the power of vite when developing while also hooking
-the live text updates into Vite's hot module reload system.
+the live text updates into Vite's hot module reload system. See [live-demo-vite](https://github.com/niels4/live-demo-vite) for a complete project setup with Typescript, React, Vite, ViTest, and a simple router.
 
 If you want to use this as a learning tool to play around with UI concepts using simple projects involving 1 html, css, and javascript file,
-then check out this [simple reference project](https://github.com/niels4/wtr-simple-example). This is a great setup for following along with any short and focused web development tutorials.
+then check out [live-demo-vanillajs](https://github.com/niels4/live-demo-vanillajs). This is a great setup for following along with any short and focused web development tutorials.
 
 And finally, the status UI for this project was also created using live updates from websocket-text-relay.
 In addition to giving you live feedback on the status and activity of the application, it is also meant to serve as a
-reference UI project that is more complicated than a single javascript file, but still doesn't use any external dependencies.
+reference UI project that doesn't use any external dependencies.
 
 ## Developing
 

package/biome.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.8/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "includes": ["src/**/*"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "lineWidth": 110
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "asNeeded"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

package/changelog.md

@@ -1,3 +1,21 @@
+## 1.1.8 - 2026/03/22
+
+### Dependencies Update
+
+- Switch to Biome for formatting and linting.
+- Switch to native nodejs test runner
+- Remove all old dependencies
+
+## 1.1.7 - 2025/12/19
+
+### UI Update
+Allow default websocket port to be overridden with url search param: `?port=38378`
+
+## 1.1.6 - 2025/12/19
+
+### UI Update
+Rewrite the UI to be simpler and fix browser compatibility issues.
+
 ## 1.1.5 - 2025/09/05
 
 Minor UI spacing fix

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "websocket-text-relay",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "An LSP server for sending live file updates from your text editor to the front end via websockets.",
   "bin": {
     "websocket-text-relay": "./start.js"
   },
   "scripts": {
-    "format": "prettier src --write",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "test": "npm run lint && vitest run --coverage",
-    "test:ui": "vitest --ui"
+    "format": "biome check --write",
+    "lint": "biome check",
+    "test:run": "node --test",
+    "test:coverage": "node --test --experimental-test-coverage",
+    "test:watch": "node --test --watch",
+    "test": "npm run lint && npm run test:run"
   },
   "type": "module",
   "main": "./src/index.js",
@@ -35,16 +36,10 @@
     "url": "https://github.com/niels4/websocket-text-relay/issues"
   },
   "homepage": "https://github.com/niels4/websocket-text-relay#readme",
-  "devDependencies": {
-    "@eslint/js": "9.39.2",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/ui": "4.0.16",
-    "eslint": "9.39.2",
-    "globals": "16.5.0",
-    "prettier": "3.7.4",
-    "vitest": "4.0.16"
-  },
   "dependencies": {
+    "@biomejs/biome": "2.4.8",
+    "@types/node": "25.5.0",
+    "typescript": "5.9.3",
     "ws": "8.18.3"
   }
 }

package/src/index.js

@@ -7,8 +7,8 @@ const resolvePort = (portParam) => {
   if (portParam != null) {
     return portParam
   }
-  if (process.env["websocket_text_relay_port"] != null) {
-    return process.env["websocket_text_relay_port"]
+  if (process.env.websocket_text_relay_port != null) {
+    return process.env.websocket_text_relay_port
   }
   return DEFAULT_WS_PORT
 }

package/src/language-server/JsonRpcInterface.js

@@ -1,6 +1,4 @@
 import { EventEmitter } from "node:events"
-import { LspReader } from "./LspReader.js"
-import { writeNotification, writeRequest, writeResponse } from "./LspWriter.js"
 import {
   invalidRequestErrorCode,
   invalidRequestErrorMessage,
@@ -11,6 +9,8 @@ import {
   unexpectedRequestErrorCode,
   unexpectedRequestErrorMessage,
 } from "./constants.js"
+import { LspReader } from "./LspReader.js"
+import { writeNotification, writeRequest, writeResponse } from "./LspWriter.js"
 
 export class JsonRpcInterface {
   constructor({ inputStream, outputStream }) {
@@ -34,7 +34,7 @@ export class JsonRpcInterface {
   onNotification(method, handler) {
     if (this.notificationHandlers.has(method)) {
       throw new Error(
-        "Can only register one notification handler at a time. Duplicate method handlers for " + method,
+        `Can only register one notification handler at a time. Duplicate method handlers for ${method}`,
       )
     }
     this.notificationHandlers.set(method, handler)
@@ -47,7 +47,7 @@ export class JsonRpcInterface {
   onRequest(method, handler) {
     if (this.requestHandlers.has(method)) {
       throw new Error(
-        "Can only register one request handler at a time. Duplicate method handlers for " + method,
+        `Can only register one request handler at a time. Duplicate method handlers for ${method}`,
       )
     }
     this.requestHandlers.set(method, handler)

package/src/language-server/JsonRpcInterface.test.js

@@ -1,7 +1,6 @@
-import { describe, it, expect, beforeAll } from "vitest"
+import assert from "node:assert/strict"
 import { PassThrough, Writable } from "node:stream"
-import { JsonRpcInterface } from "./JsonRpcInterface.js"
-import { TESTONLY_resetRequestId } from "./LspWriter.js"
+import { before as beforeAll, describe, it } from "node:test"
 import {
   invalidRequestErrorCode,
   invalidRequestErrorMessage,
@@ -12,6 +11,8 @@ import {
   unexpectedRequestErrorCode,
   unexpectedRequestErrorMessage,
 } from "./constants.js"
+import { JsonRpcInterface } from "./JsonRpcInterface.js"
+import { TESTONLY_resetRequestId } from "./LspWriter.js"
 
 describe("JsonRpcInterface", () => {
   describe("onNotification", () => {
@@ -34,14 +35,14 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
     })
 
     describe("when attempting to register duplicate onNotification handlers ", () => {
       let inputStream, outputStream, jsonRpc
-      let f1 = () => {}
-      let f2 = () => {}
+      const f1 = () => {}
+      const f2 = () => {}
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -52,9 +53,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should throw an error if we try to register the same method twice (without first removing the handler)", () => {
-        expect(() => jsonRpc.onNotification("test/test-method", f2)).to.toThrowError(
-          /duplicate method handlers/i,
-        )
+        assert.throws(() => jsonRpc.onNotification("test/test-method", f2), /duplicate method handlers/i)
       })
     })
 
@@ -63,8 +62,8 @@ describe("JsonRpcInterface", () => {
       const incomingMessage = `Content-Length: 64\r\n\r\n{"jsonrpc":"2.0","method":"test/test-method","params":{"a":"1"}}`
       let f1Fired = false
       let f2Fired = false
-      let f1 = () => (f1Fired = true)
-      let f2 = () => (f2Fired = true)
+      const f1 = () => (f1Fired = true)
+      const f2 = () => (f2Fired = true)
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -79,8 +78,8 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call function f2 instead of f1", () => {
-        expect(f1Fired).to.equal(false)
-        expect(f2Fired).to.equal(true)
+        assert.strictEqual(f1Fired, false)
+        assert.strictEqual(f2Fired, true)
       })
     })
 
@@ -111,7 +110,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
     })
 
@@ -138,7 +137,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
     })
   })
@@ -170,11 +169,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
 
       it("should write the response to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -207,23 +206,23 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
 
       it("should not write the response until the promise resolves", () => {
-        expect(actualOutput).toEqual("")
+        assert.deepStrictEqual(actualOutput, "")
       })
 
       it("should write the response after the async function resolves with the result", async () => {
         await new Promise((resolve) => setTimeout(resolve, 1))
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
     describe("when attempting to register duplicate onRequest handlers ", () => {
       let inputStream, outputStream, jsonRpc
-      let f1 = () => {}
-      let f2 = () => {}
+      const f1 = () => {}
+      const f2 = () => {}
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -234,7 +233,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should throw an error if we try to register the same method twice (without first removing the handler)", () => {
-        expect(() => jsonRpc.onRequest("test/test-method", f2)).to.toThrowError(/duplicate method handlers/i)
+        assert.throws(() => jsonRpc.onRequest("test/test-method", f2), /duplicate method handlers/i)
       })
     })
 
@@ -242,8 +241,8 @@ describe("JsonRpcInterface", () => {
       const incomingMessage = `Content-Length: 73\r\n\r\n{"jsonrpc":"2.0","id":"0","method":"test/test-method","params":{"a":"1"}}`
       let f1Fired = false
       let f2Fired = false
-      let f1 = () => (f1Fired = true)
-      let f2 = () => (f2Fired = true)
+      const f1 = () => (f1Fired = true)
+      const f2 = () => (f2Fired = true)
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -258,8 +257,8 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call function f2 instead of f1", () => {
-        expect(f1Fired).to.equal(false)
-        expect(f2Fired).to.equal(true)
+        assert.strictEqual(f1Fired, false)
+        assert.strictEqual(f2Fired, true)
       })
     })
 
@@ -299,11 +298,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should write the error to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -339,11 +338,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should write the error to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -367,7 +366,7 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should write a notification message without an ID property on the output stream", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 
@@ -399,18 +398,18 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should write the request message to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
 
       it("should return an unresolved promise", () => {
-        expect(requestPromise).toBeInstanceOf(Promise)
-        expect(actualResult).toBeNull()
+        assert.strictEqual(requestPromise instanceof Promise, true)
+        assert.strictEqual(actualResult, null)
       })
 
       it("should resolve the promise when the client responds with a result", async () => {
         inputStream.write(clientResponse)
         const result = await requestPromise
-        expect(result).to.deep.equal(expectedResult)
+        assert.deepStrictEqual(result, expectedResult)
       })
     })
 
@@ -441,18 +440,18 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should write the request message to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
 
       it("should return an unresolved promise", () => {
-        expect(requestPromise).toBeInstanceOf(Promise)
-        expect(actualResult).toBeNull()
+        assert.strictEqual(requestPromise instanceof Promise, true)
+        assert.strictEqual(actualResult, null)
       })
 
       it("should reject the promise when the client responds with an error", async () => {
         inputStream.write(clientResponse)
         await requestPromise.catch((error) => {
-          expect(error).to.deep.equal(expectedError)
+          assert.deepStrictEqual(error, expectedError)
         })
       })
     })
@@ -476,7 +475,7 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should write the error to the output stream", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 
@@ -516,11 +515,11 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should emit an rpc-error event on the events emitter", () => {
-      expect(actualError).to.deep.equal(expectedError)
+      assert.deepStrictEqual(actualError, expectedError)
     })
 
     it("should notify the client that it sent an invalid rpc message", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 })

package/src/language-server/LspReader.js

@@ -23,7 +23,7 @@ const getJsonLength = (data, bufferStartIndex, jsonStartIndex) => {
   if (!match) {
     return null
   }
-  return Number.parseInt(match[1])
+  return Number.parseInt(match[1], 10)
 }
 
 export class LspReader extends Transform {

package/src/language-server/LspReader.test.js

@@ -1,7 +1,8 @@
+import assert from "node:assert/strict"
 import { PassThrough } from "node:stream"
-import { describe, it, expect, beforeAll } from "vitest"
-import { LspReader } from "./LspReader.js"
+import { before as beforeAll, describe, it } from "node:test"
 import { parseErrorCode, parseHeaderErrorMessage, parseJsonErrorMessage } from "./constants.js"
+import { LspReader } from "./LspReader.js"
 
 describe("LspReader", () => {
   describe("simple case", () => {
@@ -26,7 +27,7 @@ describe("LspReader", () => {
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -51,7 +52,7 @@ describe("LspReader", () => {
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -77,11 +78,11 @@ describe("LspReader", () => {
       })
 
       it("should emit an 'parse-error' event with the parse header error message", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should not emit any objects", () => {
-        expect(actualMessageObj).toBeNull()
+        assert.strictEqual(actualMessageObj, null)
       })
     })
 
@@ -97,8 +98,8 @@ describe("LspReader", () => {
         method: "test/test-method",
         params: { b: "2" },
       }
-      let actualMessageObjs = []
-      let actualErrors = []
+      const actualMessageObjs = []
+      const actualErrors = []
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -116,13 +117,13 @@ describe("LspReader", () => {
       })
 
       it("should emit only 1 'parse-error' event with the parse header error message", () => {
-        expect(actualErrors.length).toEqual(1)
-        expect(actualErrors[0]).to.deep.equal(expectedError)
+        assert.strictEqual(actualErrors.length, 1)
+        assert.deepStrictEqual(actualErrors[0], expectedError)
       })
 
       it("should not emit one object from the message with the valid header", () => {
-        expect(actualMessageObjs.length).toEqual(1)
-        expect(actualMessageObjs[0]).to.deep.equal(expectedObject)
+        assert.strictEqual(actualMessageObjs.length, 1)
+        assert.deepStrictEqual(actualMessageObjs[0], expectedObject)
       })
     })
 
@@ -138,8 +139,8 @@ describe("LspReader", () => {
         method: "test/test-method",
         params: { b: "2" },
       }
-      let actualMessageObjs = []
-      let actualErrors = []
+      const actualMessageObjs = []
+      const actualErrors = []
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -157,13 +158,13 @@ describe("LspReader", () => {
       })
 
       it("should emit only 1 'parse-error' event with the parse header error message", () => {
-        expect(actualErrors.length).toEqual(1)
-        expect(actualErrors[0]).to.deep.equal(expectedError)
+        assert.strictEqual(actualErrors.length, 1)
+        assert.deepStrictEqual(actualErrors[0], expectedError)
       })
 
       it("should not emit one object from the message with the valid header", () => {
-        expect(actualMessageObjs.length).toEqual(1)
-        expect(actualMessageObjs[0]).to.deep.equal(expectedObject)
+        assert.strictEqual(actualMessageObjs.length, 1)
+        assert.deepStrictEqual(actualMessageObjs[0], expectedObject)
       })
     })
 
@@ -187,11 +188,11 @@ describe("LspReader", () => {
       })
 
       it("should emit an 'parse-error' event with the parse JSON error message", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should not emit any objects", () => {
-        expect(actualMessageObj).toBeNull()
+        assert.strictEqual(actualMessageObj, null)
       })
     })
   })
@@ -228,11 +229,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -274,11 +275,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -313,11 +314,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -362,11 +363,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -396,19 +397,19 @@ describe("LspReader", () => {
       })
 
       it("should construct the lspReader with the passed in initialBufferSize", () => {
-        expect(actualInitialBufferSize).toEqual(10)
+        assert.strictEqual(actualInitialBufferSize, 10)
       })
 
       it("should need to trigger a resize", () => {
-        expect(inputData.length).toBeGreaterThan(actualInitialBufferSize)
+        assert.strictEqual(inputData.length > actualInitialBufferSize, true)
       })
 
       it("should increase the buffer to a size larger than the message chunk", () => {
-        expect(lspReader.buffer.length).toBeGreaterThan(inputData.length)
+        assert.strictEqual(lspReader.buffer.length > inputData.length, true)
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -446,24 +447,24 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should construct the lspReader with the passed in initialBufferSize", () => {
-        expect(actualInitialBufferSize).toEqual(70)
+        assert.strictEqual(actualInitialBufferSize, 70)
       })
 
       it("should need to trigger a resize after the first buffered message", () => {
-        expect(inputData[0].length).toBeLessThan(actualInitialBufferSize)
-        expect(inputData[1].length).toBeGreaterThan(actualInitialBufferSize)
+        assert.strictEqual(inputData[0].length < actualInitialBufferSize, true)
+        assert.strictEqual(inputData[1].length > actualInitialBufferSize, true)
       })
 
       it("should increase the buffer to a size larger than the combined message chunks", () => {
-        expect(lspReader.buffer.length).toBeGreaterThan(inputData[0].length + inputData[1].length)
+        assert.strictEqual(lspReader.buffer.length > inputData[0].length + inputData[1].length, true)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -480,7 +481,7 @@ describe("LspReader", () => {
       { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
       { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
     ]
-    let actualMessageObjs = []
+    const actualMessageObjs = []
     let actualError = null
 
     beforeAll(() => {
@@ -500,11 +501,11 @@ describe("LspReader", () => {
     })
 
     it("should not emit an error", () => {
-      expect(actualError).toBeNull()
+      assert.strictEqual(actualError, null)
     })
 
     it("should emit each message in the order it was received", () => {
-      expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+      assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
     })
   })
 
@@ -521,7 +522,7 @@ describe("LspReader", () => {
       { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
       { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
     ]
-    let actualMessageObjs = []
+    const actualMessageObjs = []
     let actualError = null
 
     beforeAll(() => {
@@ -539,11 +540,11 @@ describe("LspReader", () => {
     })
 
     it("should not emit an error", () => {
-      expect(actualError).toBeNull()
+      assert.strictEqual(actualError, null)
     })
 
     it("should emit each message in the order it was received", () => {
-      expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+      assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
     })
   })
 
@@ -559,7 +560,7 @@ describe("LspReader", () => {
         { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
         { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
       ]
-      let actualMessageObjs = []
+      const actualMessageObjs = []
       let actualError = null
 
       beforeAll(() => {
@@ -579,11 +580,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should emit each message in the order it was received", () => {
-        expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+        assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
       })
     })
   })

package/src/language-server/LspWriter.test.js

@@ -1,8 +1,9 @@
+import assert from "node:assert/strict"
 import { Writable } from "node:stream"
-import { describe, it, expect, beforeAll } from "vitest"
+import { before as beforeAll, describe, it } from "node:test"
 import {
-  TESTONLY_resetRequestId,
   createHeader,
+  TESTONLY_resetRequestId,
   writeNotification,
   writeRequest,
   writeResponse,
@@ -17,7 +18,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
 
@@ -27,7 +28,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
 
@@ -37,7 +38,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct byte length, not string length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
   })
@@ -59,7 +60,7 @@ describe("LspWriter", () => {
       })
 
       it("should stringify the json and add a Content-Length header, then write the head and json to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -82,7 +83,7 @@ describe("LspWriter", () => {
       })
 
       it("should create a response object with a result property (and no error) and write it to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -103,7 +104,7 @@ describe("LspWriter", () => {
       })
 
       it("should create a response object with an error property (and no result) and write it to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -126,7 +127,7 @@ describe("LspWriter", () => {
       })
 
       it("should write a notification message without an ID property on the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -150,7 +151,7 @@ describe("LspWriter", () => {
       })
 
       it("should write a request message with an ID property on the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -179,7 +180,7 @@ describe("LspWriter", () => {
       })
 
       it("should write multiple request messages with increasing IDs", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })

package/src/ui/index.html

@@ -1,41 +1,44 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 
-    <title>WTR Status</title>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 
-    <link rel="icon" type="image/png" href="favicon.png" />
-    <link rel="stylesheet" href="css/fonts.css" />
-    <style id="main_style"></style>
-    <script type="module" src="js/setup.js" defer></script>
+  <title>WTR Status</title>
 
-    <style>
-      html {
-        height: 100dvh;
-        overscroll-behavior: none;
-      }
+  <link rel="icon" type="image/png" href="favicon.png" />
+  <link rel="stylesheet" href="css/fonts.css" />
+  <style id="main_style"></style>
+  <script type="module" src="js/setup.js" defer></script>
 
-      #svg_root {
-        position: absolute;
-        top: 0;
-        left: 0;
-        height: 100dvh;
-        width: 100dvw;
-      }
-    </style>
-  </head>
+  <style>
+    html {
+      height: 100dvh;
+      overscroll-behavior: none;
+    }
+
+    #svg_root {
+      position: absolute;
+      top: 0;
+      left: 0;
+      height: 100dvh;
+      width: 100dvw;
+    }
+  </style>
+</head>
+
+<body class="base_colors color_theme">
+  <svg id="svg_root" viewBox="-1 -1 2 2" xmlns="http://www.w3.org/2000/svg">
+    <title>Main Svg Canvas</title>
+    <g id="headers_group"></g>
+    <g id="editor_wedges_group" class="wedge_group"></g>
+    <g id="client_wedges_group" class="wedge_group"></g>
+    <g id="activity_time_series_group"></g>
+    <g id="activity_labels_group"></g>
+    <g id="status_ring_group"></g>
+    <g id="footer_status_group"></g>
+  </svg>
+</body>
 
-  <body class="base_colors color_theme">
-    <svg id="svg_root" viewBox="-1 -1 2 2" xmlns="http://www.w3.org/2000/svg">
-      <g id="headers_group"></g>
-      <g id="editor_wedges_group" class="wedge_group"></g>
-      <g id="client_wedges_group" class="wedge_group"></g>
-      <g id="activity_time_series_group"></g>
-      <g id="activity_labels_group"></g>
-      <g id="status_ring_group"></g>
-      <g id="footer_status_group"></g>
-    </svg>
-  </body>
 </html>

package/src/ui/js/data/wtrActivity.js

@@ -66,7 +66,7 @@ function processDataWindow(dataWindow) {
     }
     return `${i},${value}`
   })
-  const path = "M " + coords.join(" L ")
+  const path = `M ${coords.join(" L ")}`
   return { path, maxValue }
 }
 

package/src/ui/js/data/wtrStatus.js

@@ -14,7 +14,7 @@ const currentStatus = {
 }
 
 const wtrStatusEmitter = new EventEmitter()
-wtrStatusEmitter.on = function (event, handler) {
+wtrStatusEmitter.on = (event, handler) => {
   EventEmitter.prototype.on.call(wtrStatusEmitter, event, handler)
   // automatically push the data to the event handler when it initially subscribes
   if (event === "data") {

package/src/ui/js/setup/eventSubscriber.js

@@ -2,6 +2,7 @@ const allCleanupFunctions = new Map()
 
 export const eventSubscriber = (key) => {
   const previousCleanupFunctions = allCleanupFunctions.get(key)
+  // biome-ignore lint/suspicious/useIterableCallbackReturn: Keep the function a 1 liner
   previousCleanupFunctions?.forEach((f) => f())
 
   const cleanupFunctions = []

package/src/ui/js/setup.js

@@ -1,11 +1,13 @@
-import { WebsocketClient } from "./setup/WebsocketClient.js"
-import { getEvalOnChangeFiles, clearEvalOnChangeFiles } from "./setup/evalOnChange.js" // initialize dependencies on the global __WTR__ object
+import { emitActivity } from "./data/wtrActivity.js"
 import { setIsOnline, setSessions } from "./data/wtrStatus.js"
+import { clearEvalOnChangeFiles, getEvalOnChangeFiles } from "./setup/evalOnChange.js" // initialize dependencies on the global __WTR__ object
 import { eventSubscriber } from "./setup/eventSubscriber.js" // make sure the eventSubscriber function is available on the __WTR__ object
-import { emitActivity } from "./data/wtrActivity.js"
+import { WebsocketClient } from "./setup/WebsocketClient.js"
+
+const searchParams = new URLSearchParams(window.location.search)
 
 const FILE_PREFIX = "websocket-text-relay/src/ui/"
-const WS_PORT = 38378
+const wsPort = searchParams.get("port") ?? 38378
 const { hostname, protocol } = window.location
 const wsProtocol = protocol === "http:" ? "ws" : "wss"
 const CSS_FILE = "css/main.css"
@@ -25,7 +27,7 @@ const jsFiles = [
   "js/components/activityLabels.js",
 ]
 
-const ws = new WebsocketClient({ port: WS_PORT, host: hostname, protocol: wsProtocol })
+const ws = new WebsocketClient({ port: wsPort, host: hostname, protocol: wsProtocol })
 
 const cssElement = document.getElementById("main_style")
 
@@ -37,6 +39,7 @@ const handleJs = (contents, jsEndsWith) => {
   // register and clean up event handlers on a per file basis
   window.__WTR__.onEvent = eventSubscriber(jsEndsWith)
   try {
+    // biome-ignore lint/security/noGlobalEval: Live updates requires eval
     eval(contents)
   } catch (e) {
     window._lastEvalError = e

package/src/websocket-interface/WebsocketInterface.js

@@ -1,8 +1,8 @@
+import { EventEmitter } from "node:events"
 import { WebsocketClient } from "./WebsocketClient.js"
 import { WtrSession } from "./WtrSession.js"
 import { apiMethods } from "./websocketApi.js"
 import { createWebsocketServer } from "./websocketServer.js"
-import { EventEmitter } from "node:events"
 
 const watchActiveFilesMessage = { method: "watch-editor-active-files" }
 
@@ -81,7 +81,7 @@ export class WebsocketInterface {
   _sendMessageToServer(message) {
     if (this.serverSession) {
       this.serverSession._handleApiMessage(message)
-    } else if (this.wsClient && this.wsClient.socketOpen) {
+    } else if (this.wsClient?.socketOpen) {
       this.wsClient.sendMessage(message)
     }
   }

package/src/websocket-interface/WtrSession.js

@@ -1,11 +1,11 @@
 import { EventEmitter } from "node:events"
-import { getNextId } from "./util.js"
 import {
-  startSessionStatus,
   endSessionStatus,
-  statusEvents,
   removeWatchedFileLinks,
+  startSessionStatus,
+  statusEvents,
 } from "./sessionManager.js"
+import { getNextId } from "./util.js"
 
 export class WtrSession {
   constructor({ apiMethods, wsConnection, wsInterfaceEmitter }) {
@@ -118,7 +118,7 @@ export class WtrSession {
   }
 
   _handleApiMessage(message) {
-    const method = message && message.method
+    const method = message?.method
     const methodHandler = this.apiMethods.get(method)
     if (!methodHandler) {
       this.emitter.emit("log", { level: "error", text: `unknown ws api method: ${method}` })

package/src/websocket-interface/httpServer.js

@@ -1,9 +1,10 @@
-import { createServer } from "node:http"
-import path from "node:path"
 import { createReadStream } from "node:fs"
 import fs from "node:fs/promises"
+import { createServer } from "node:http"
+import path from "node:path"
 import * as url from "node:url"
 import { isValidOrigin } from "./util.js"
+
 const parentDir = url.fileURLToPath(new URL("..", import.meta.url))
 
 const uiDirName = "ui"
@@ -19,7 +20,7 @@ const allowedFileTypes = new Map([
 ])
 
 const getFilePath = (url) => {
-  url = url === "/" ? "./index.html" : "." + url
+  url = url === "/" ? "./index.html" : `.${url}`
   return path.join(uiDirPath, url)
 }
 

package/src/websocket-interface/websocketApi.js

@@ -1,10 +1,10 @@
 import {
-  triggerStatusUpdate,
-  statusEvents,
+  addOpenedFileLinks,
   addWatchedFileLinks,
-  removeWatchedFileLinks,
   removeOpenedFileLinks,
-  addOpenedFileLinks,
+  removeWatchedFileLinks,
+  statusEvents,
+  triggerStatusUpdate,
 } from "./sessionManager.js"
 
 export const apiMethods = new Map([

package/src/websocket-interface/websocketServer.js

@@ -1,8 +1,8 @@
 import { WebSocketServer } from "ws"
 import { createHttpServer } from "./httpServer.js"
-import { apiMethods } from "./websocketApi.js"
-import { WtrSession } from "./WtrSession.js"
 import { isValidOrigin } from "./util.js"
+import { WtrSession } from "./WtrSession.js"
+import { apiMethods } from "./websocketApi.js"
 
 export const createWebsocketServer = async ({ port, allowedHosts, allowNetworkAccess }) => {
   const httpServer = await createHttpServer({ port, allowedHosts, allowNetworkAccess }) // promise will reject if can't start HTTP server on specified port

package/.prettierignore

@@ -1,3 +0,0 @@
-# Ignore artifacts:
-build
-coverage

package/.prettierrc

@@ -1,4 +0,0 @@
-{
-  "semi": false,
-  "printWidth": 110
-}

package/eslint.config.js

@@ -1,32 +0,0 @@
-import js from "@eslint/js"
-import globals from "globals"
-import { defineConfig } from "eslint/config"
-
-const wtrGlobals = {
-  __WTR__: "readonly",
-}
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs}"],
-    plugins: { js },
-    extends: ["js/recommended"],
-    languageOptions: { globals: { ...globals.node, ...globals.browser, ...wtrGlobals } },
-  },
-  {
-    rules: {
-      semi: ["error", "never"],
-      indent: ["error", 2],
-      "no-multiple-empty-lines": ["error", { max: 1 }],
-      "no-unused-vars": 1,
-      "no-return-assign": 0,
-      "multiline-ternary": 0,
-      "object-curly-spacing": 0,
-      "object-property-newline": 0,
-      "object-curly-newline": 0,
-      quotes: 0,
-      "quote-props": 0,
-      "import/no-absolute-path": 0,
-    },
-  },
-])