websocket-text-relay 1.1.2 → 1.1.4

package/src/websocket-interface/WtrSession.js

@@ -1,9 +1,14 @@
-import { EventEmitter } from 'node:events'
+import { EventEmitter } from "node:events"
 import { getNextId } from "./util.js"
-import { startSessionStatus, endSessionStatus, statusEvents, removeWatchedFileLinks } from './sessionManager.js'
+import {
+  startSessionStatus,
+  endSessionStatus,
+  statusEvents,
+  removeWatchedFileLinks,
+} from "./sessionManager.js"
 
 export class WtrSession {
-  constructor ({apiMethods, wsConnection, wsInterfaceEmitter}) {
+  constructor({ apiMethods, wsConnection, wsInterfaceEmitter }) {
     this.apiMethods = apiMethods
     this.wsConnection = wsConnection
     this.wsInterfaceEmitter = wsInterfaceEmitter
@@ -22,45 +27,45 @@ export class WtrSession {
     startSessionStatus(this)
   }
 
-  sendMessageToClient (message) {
+  sendMessageToClient(message) {
     if (this.wsConnection) {
       this.wsConnection.send(JSON.stringify(message))
     } else {
-      this.wsInterfaceEmitter.emit('message', message)
+      this.wsInterfaceEmitter.emit("message", message)
     }
   }
 
-  isServer () {
+  isServer() {
     return this.wsInterfaceEmitter != null
   }
 
   _subscribeToEvents = () => {
-    this.emitter.on('log', this._onLog.bind(this))
-    this.emitter.on('editor-active-files-update', this._onEditorActiveFilesUpdate.bind(this))
+    this.emitter.on("log", this._onLog.bind(this))
+    this.emitter.on("editor-active-files-update", this._onEditorActiveFilesUpdate.bind(this))
 
     this._onActivityUpdate = this._onActivityUpdate.bind(this)
-    statusEvents.on('activity-update', this._onActivityUpdate)
+    statusEvents.on("activity-update", this._onActivityUpdate)
     this._onStatusUpdate = this._onStatusUpdate.bind(this)
-    statusEvents.on('status-update', this._onStatusUpdate)
+    statusEvents.on("status-update", this._onStatusUpdate)
 
     if (this.wsConnection) {
       this._onWsMessage = this._onWsMessage.bind(this)
       this._onWsClose = this._onWsClose.bind(this)
-      this.wsConnection.on('message', this._onWsMessage)
-      this.wsConnection.on('close', this._onWsClose)
-      this.wsConnection.on('error', this._onWsClose)
+      this.wsConnection.on("message", this._onWsMessage)
+      this.wsConnection.on("close", this._onWsClose)
+      this.wsConnection.on("error", this._onWsClose)
     }
   }
 
-  _onWsClose () {
+  _onWsClose() {
     if (this.wsConnection) {
-      this.wsConnection.removeListener('message', this._onWsMessage)
-      this.wsConnection.removeListener('close', this._onWsClose)
-      this.wsConnection.removeListener('error', this._onWsClose)
+      this.wsConnection.removeListener("message", this._onWsMessage)
+      this.wsConnection.removeListener("close", this._onWsClose)
+      this.wsConnection.removeListener("error", this._onWsClose)
     }
 
-    statusEvents.removeListener('activity-update', this._onEditorActiveFilesUpdate)
-    statusEvents.removeListener('status-update', this._onStatusUpdate)
+    statusEvents.removeListener("activity-update", this._onEditorActiveFilesUpdate)
+    statusEvents.removeListener("status-update", this._onStatusUpdate)
 
     endSessionStatus(this)
     for (const endsWith of this.watchedFiles) {
@@ -70,52 +75,63 @@ export class WtrSession {
     this.emitter.removeAllListeners()
   }
 
-  _onLog (data) {
-    if (!this.watchLogMessages) { return }
+  _onLog(data) {
+    if (!this.watchLogMessages) {
+      return
+    }
     this.sendMessageToClient({ method: "watch-log-messages", data })
   }
 
-  _onEditorActiveFilesUpdate (files) {
-    if (!this.watchActiveFiles) { return }
+  _onEditorActiveFilesUpdate(files) {
+    if (!this.watchActiveFiles) {
+      return
+    }
     this.sendMessageToClient({ method: "watch-editor-active-files", files })
   }
 
-  _onActivityUpdate (data) {
-    if (!this.watchWtrActivity) { return }
+  _onActivityUpdate(data) {
+    if (!this.watchWtrActivity) {
+      return
+    }
     this.sendMessageToClient({ method: "watch-wtr-activity", data })
   }
 
-  _onStatusUpdate (data) {
-    if (!this.watchWtrStatus) { return }
+  _onStatusUpdate(data) {
+    if (!this.watchWtrStatus) {
+      return
+    }
     this.sendMessageToClient({ method: "watch-wtr-status", data })
   }
 
-  _onWsMessage (dataBuf) {
+  _onWsMessage(dataBuf) {
     const str = dataBuf.toString()
     let message
 
     try {
       message = JSON.parse(str)
-    } catch (e) {
-      this.emitter.emit('log', { level: "error", text: `Could not parse JSON message: ${str}` })
+    } catch {
+      this.emitter.emit("log", { level: "error", text: `Could not parse JSON message: ${str}` })
       return
     }
 
     this._handleApiMessage(message)
   }
 
-  _handleApiMessage (message) {
+  _handleApiMessage(message) {
     const method = message && message.method
     const methodHandler = this.apiMethods.get(method)
     if (!methodHandler) {
-      this.emitter.emit('log', { level: "error", text: `unknown ws api method: ${method}` })
+      this.emitter.emit("log", { level: "error", text: `unknown ws api method: ${method}` })
       return
     }
 
     try {
       methodHandler(this, message)
     } catch (e) {
-      this.emitter.emit('log', { level: "error", text: `Error while handling method: ${method} : ${e.stacktrace}` })
+      this.emitter.emit("log", {
+        level: "error",
+        text: `Error while handling method: ${method} : ${e.stacktrace}`,
+      })
       console.error("Error while handling ws api method", method, e)
     }
   }

package/src/websocket-interface/httpServer.js

@@ -1,9 +1,10 @@
-import { createServer } from 'node:http'
-import path from 'node:path'
-import fs from 'node:fs'
-import * as url from 'node:url'
-import { isValidOrigin } from './util.js'
-const parentDir = url.fileURLToPath(new URL('..', import.meta.url))
+import { createServer } from "node:http"
+import path from "node:path"
+import { createReadStream } from "node:fs"
+import fs from "node:fs/promises"
+import * as url from "node:url"
+import { isValidOrigin } from "./util.js"
+const parentDir = url.fileURLToPath(new URL("..", import.meta.url))
 
 const uiDirName = "ui"
 const uiDirPath = path.join(parentDir, uiDirName)
@@ -24,7 +25,9 @@ const getFilePath = (url) => {
 
 const getFileType = (fileUrl) => {
   const lastDotIndex = fileUrl.lastIndexOf(".")
-  if (lastDotIndex < 0 || lastDotIndex >= fileUrl.length) { return "" }
+  if (lastDotIndex < 0 || lastDotIndex >= fileUrl.length) {
+    return ""
+  }
   return fileUrl.substring(lastDotIndex + 1)
 }
 
@@ -41,16 +44,23 @@ const requestHandler = (allowedHosts) => (req, res) => {
     res.writeHead(404)
     res.end("NOT FOUND!")
     return
-  } 
-  res.setHeader("Content-Type", contentType)
-  res.writeHead(200)
-  const fileStream = fs.createReadStream(filePath)
-  fileStream.pipe(res)
+  }
+
+  fs.access(filePath, fs.constants.R_OK)
+    .then(() => {
+      res.setHeader("Content-Type", contentType)
+      res.writeHead(200)
+      const fileStream = createReadStream(filePath)
+      fileStream.pipe(res)
+    })
+    .catch((e) => {
+      res.writeHead(404)
+      res.end("NOT FOUND!")
+    })
 }
 
-export const createHttpServer = ({port, allowedHosts, allowNetworkAccess}) => {
+export const createHttpServer = ({ port, allowedHosts, allowNetworkAccess }) => {
   return new Promise((resolve, reject) => {
-    
     const server = createServer(requestHandler(allowedHosts))
 
     server.on("error", (e) => {

package/src/websocket-interface/sessionManager.js

@@ -1,5 +1,5 @@
-import { EventEmitter } from 'node:events'
-import { debounce } from './util.js'
+import { EventEmitter } from "node:events"
+import { debounce } from "./util.js"
 
 export const statusEvents = new EventEmitter()
 
@@ -7,14 +7,13 @@ export const wtrSessions = new Set()
 
 const createUpdateObject = () => {
   const sessions = [...wtrSessions].map((wtrSession) => {
-
     const openFileLinks = {}
     for (const [editorFile, fileLinks] of wtrSession.activeOpenFiles) {
       if (!openFileLinks[editorFile]) {
         openFileLinks[editorFile] = []
       }
-      for (const {clientSession, endsWith} of fileLinks.values()) {
-        openFileLinks[editorFile].push({clientId: clientSession.id, endsWith})
+      for (const { clientSession, endsWith } of fileLinks.values()) {
+        openFileLinks[editorFile].push({ clientId: clientSession.id, endsWith })
       }
     }
 
@@ -26,16 +25,16 @@ const createUpdateObject = () => {
       isServer: wtrSession.isServer(),
       watchCount: wtrSession.watchedFiles.size,
       openCount: wtrSession.openFiles.size,
-      openFileLinks
+      openFileLinks,
     }
   })
 
-  return {sessions}
+  return { sessions }
 }
 
 const sendUpdate = () => {
   const updateObject = createUpdateObject()
-  statusEvents.emit('status-update', updateObject)
+  statusEvents.emit("status-update", updateObject)
 }
 
 export const triggerStatusUpdate = debounce(100, sendUpdate)
@@ -61,12 +60,14 @@ const createWatchLink = (wtrSession, editorFile, clientSession, endsWith) => {
   const linkKey = createLinkKey(clientSession, endsWith)
   fileLinks.set(linkKey, { clientSession, endsWith })
   triggerStatusUpdate()
-  wtrSession.emitter.emit('editor-active-files-update', [...wtrSession.activeOpenFiles.keys()])
+  wtrSession.emitter.emit("editor-active-files-update", [...wtrSession.activeOpenFiles.keys()])
 }
 
 export const addOpenedFileLinks = (wtrSession, editorFile) => {
   for (const clientSession of wtrSessions) {
-    if (clientSession === wtrSession) { continue }
+    if (clientSession === wtrSession) {
+      continue
+    }
     for (const endsWith of clientSession.watchedFiles) {
       if (editorFile.endsWith(endsWith)) {
         createWatchLink(wtrSession, editorFile, clientSession, endsWith)
@@ -77,13 +78,15 @@ export const addOpenedFileLinks = (wtrSession, editorFile) => {
 
 export const removeOpenedFileLinks = (wtrSession, editorFile) => {
   wtrSession.activeOpenFiles.delete(editorFile)
-  wtrSession.emitter.emit('editor-active-files-update', [...wtrSession.activeOpenFiles.keys()])
+  wtrSession.emitter.emit("editor-active-files-update", [...wtrSession.activeOpenFiles.keys()])
   triggerStatusUpdate()
 }
 
 export const addWatchedFileLinks = (clientSession, endsWith) => {
   for (const wtrSession of wtrSessions) {
-    if (wtrSession === clientSession) { continue }
+    if (wtrSession === clientSession) {
+      continue
+    }
     for (const editorFile of wtrSession.openFiles) {
       if (editorFile.endsWith(endsWith)) {
         createWatchLink(wtrSession, editorFile, clientSession, endsWith)
@@ -99,7 +102,7 @@ export const removeWatchedFileLinks = (clientSession, endsWith) => {
       fileLinks.delete(linkKey)
       if (fileLinks.size === 0) {
         wtrSession.activeOpenFiles.delete(editorFile)
-        wtrSession.emitter.emit('editor-active-files-update', [...wtrSession.activeOpenFiles.keys()])
+        wtrSession.emitter.emit("editor-active-files-update", [...wtrSession.activeOpenFiles.keys()])
         triggerStatusUpdate()
       }
     }

package/src/websocket-interface/util.js

@@ -14,7 +14,7 @@ export const getNextId = () => currentId++
 const defaultAllowedHost = "localhost"
 
 export const isValidOrigin = (allowedHosts, req) => {
-  const {host, origin} = req.headers
+  const { host, origin } = req.headers
   let hostname
 
   if (origin == null || origin.length === 0) {

package/src/websocket-interface/websocketApi.js

@@ -1,4 +1,11 @@
-import { triggerStatusUpdate, statusEvents, addWatchedFileLinks, removeWatchedFileLinks, removeOpenedFileLinks, addOpenedFileLinks } from './sessionManager.js'
+import {
+  triggerStatusUpdate,
+  statusEvents,
+  addWatchedFileLinks,
+  removeWatchedFileLinks,
+  removeOpenedFileLinks,
+  addOpenedFileLinks,
+} from "./sessionManager.js"
 
 export const apiMethods = new Map([
   ["watch-log-messages", watchLogMessages],
@@ -16,45 +23,51 @@ export const apiMethods = new Map([
   ["unwatch-wtr-activity", unwatchWtrActivity],
 ])
 
-function watchLogMessages (wtrSession) {
+function watchLogMessages(wtrSession) {
   wtrSession.watchLogMessages = true
-  wtrSession.emitter.emit('log', { level: "info", text: "Watching WTR log messages" })
+  wtrSession.emitter.emit("log", { level: "info", text: "Watching WTR log messages" })
 }
 
-function unwatchLogMessages (wtrSession) {
-  wtrSession.emitter.emit('log', { level: "info", text: "Unwatching WTR log messages" })
+function unwatchLogMessages(wtrSession) {
+  wtrSession.emitter.emit("log", { level: "info", text: "Unwatching WTR log messages" })
   wtrSession.watchLogMessages = false
 }
 
-function init (wtrSession, data) {
+function init(wtrSession, data) {
   wtrSession.name = data.name
   wtrSession.editorPid = data.editorPid
   wtrSession.lsPid = data.lsPid
   triggerStatusUpdate()
-  wtrSession.emitter.emit('log', { level: "info", text: "Init success" })
+  wtrSession.emitter.emit("log", { level: "info", text: "Init success" })
 }
 
-function watchFile (wtrSession, data) {
+function watchFile(wtrSession, data) {
   if (data.endsWith == null || data.endsWith.length === 0) {
-    wtrSession.emitter.emit('log', { level: "error", text: "Must provide an endsWith property" })
+    wtrSession.emitter.emit("log", { level: "error", text: "Must provide an endsWith property" })
     return
   }
   wtrSession.watchedFiles.add(data.endsWith)
   addWatchedFileLinks(wtrSession, data.endsWith)
-  wtrSession.emitter.emit('log', { level: "info", text: `Watching files that end with ${data.endsWith}` })
+  wtrSession.emitter.emit("log", {
+    level: "info",
+    text: `Watching files that end with ${data.endsWith}`,
+  })
 }
 
-function unwatchFile (wtrSession, data) {
+function unwatchFile(wtrSession, data) {
   if (data.endsWith == null || data.endsWith.length === 0) {
-    wtrSession.emitter.emit('log', { level: "error", text: "Must provide an endsWith property" })
+    wtrSession.emitter.emit("log", { level: "error", text: "Must provide an endsWith property" })
     return
   }
   wtrSession.watchedFiles.delete(data.endsWith)
   removeWatchedFileLinks(wtrSession, data.endsWith)
-  wtrSession.emitter.emit('log', { level: "info", text: `No longer watching files that end with ${data.endsWith}` })
+  wtrSession.emitter.emit("log", {
+    level: "info",
+    text: `No longer watching files that end with ${data.endsWith}`,
+  })
 }
 
-function updateEditorOpenFiles (wtrSession, data) {
+function updateEditorOpenFiles(wtrSession, data) {
   const updatedFileSet = new Set(data.files)
   for (const fileName of wtrSession.openFiles) {
     if (!updatedFileSet.has(fileName)) {
@@ -71,46 +84,50 @@ function updateEditorOpenFiles (wtrSession, data) {
   triggerStatusUpdate()
 }
 
-function watchEditorActiveFiles (wtrSession) {
+function watchEditorActiveFiles(wtrSession) {
   wtrSession.watchActiveFiles = true
-  wtrSession.emitter.emit('log', { level: "info", text: "Watching editor active files" })
+  wtrSession.emitter.emit("log", { level: "info", text: "Watching editor active files" })
 }
 
-function unwatchEditorActiveFiles (wtrSession) {
-  wtrSession.emitter.emit('log', { level: "info", text: "Unwatching editor active files" })
+function unwatchEditorActiveFiles(wtrSession) {
+  wtrSession.emitter.emit("log", { level: "info", text: "Unwatching editor active files" })
   wtrSession.watchActiveFiles = false
 }
 
-function relayText (wtrSession, data) {
-  if (!data || !data.file) { return }
-  const {file, contents} = data
+function relayText(wtrSession, data) {
+  if (!data || !data.file) {
+    return
+  }
+  const { file, contents } = data
   const watchers = wtrSession.activeOpenFiles.get(file)
-  if (!watchers) { return }
+  if (!watchers) {
+    return
+  }
   const watcherSessionIds = []
-  for (const {clientSession: watcherWtrSession, endsWith} of watchers.values()) {
+  for (const { clientSession: watcherWtrSession, endsWith } of watchers.values()) {
     watcherSessionIds.push(watcherWtrSession.id)
-    watcherWtrSession.sendMessageToClient({method: "watch-file", endsWith, contents})
+    watcherWtrSession.sendMessageToClient({ method: "watch-file", endsWith, contents })
   }
-  const activityData = {action: "relay", relayer: wtrSession.id, watchers: watcherSessionIds}
-  statusEvents.emit('activity-update', activityData)
+  const activityData = { action: "relay", relayer: wtrSession.id, watchers: watcherSessionIds }
+  statusEvents.emit("activity-update", activityData)
 }
 
-function watchWtrStatus (wtrSession) {
+function watchWtrStatus(wtrSession) {
   wtrSession.watchWtrStatus = true
-  wtrSession.emitter.emit('log', { level: "info", text: "Watching WTR status updates" })
+  wtrSession.emitter.emit("log", { level: "info", text: "Watching WTR status updates" })
 }
 
-function unwatchWtrStatus (wtrSession) {
-  wtrSession.emitter.emit('log', { level: "info", text: "Unwatching WTR status updates" })
+function unwatchWtrStatus(wtrSession) {
+  wtrSession.emitter.emit("log", { level: "info", text: "Unwatching WTR status updates" })
   wtrSession.watchWtrStatus = false
 }
 
-function watchWtrActivity (wtrSession) {
+function watchWtrActivity(wtrSession) {
   wtrSession.watchWtrActivity = true
-  wtrSession.emitter.emit('log', { level: "info", text: "Watching WTR activity events" })
+  wtrSession.emitter.emit("log", { level: "info", text: "Watching WTR activity events" })
 }
 
-function unwatchWtrActivity (wtrSession) {
-  wtrSession.emitter.emit('log', { level: "info", text: "Unwatching WTR activity events" })
+function unwatchWtrActivity(wtrSession) {
+  wtrSession.emitter.emit("log", { level: "info", text: "Unwatching WTR activity events" })
   wtrSession.watchWtrActivity = false
 }

package/src/websocket-interface/websocketServer.js

@@ -1,22 +1,22 @@
-import { WebSocketServer } from 'ws'
+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 { isValidOrigin } from "./util.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
+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
 
   const websocketServer = new WebSocketServer({ server: httpServer })
-  
-  websocketServer.on('error', () =>  { })
 
-  websocketServer.on('connection', (wsConnection, request) => {
+  websocketServer.on("error", () => {})
+
+  websocketServer.on("connection", (wsConnection, request) => {
     if (!isValidOrigin(allowedHosts, request)) {
       wsConnection.close()
       return
     }
-    new WtrSession({apiMethods, wsConnection})
+    new WtrSession({ apiMethods, wsConnection })
   })
 
   return websocketServer

package/start.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { startLanguageServer } from "./index.js"
+import { startLanguageServer } from "./src/index.js"
 
 startLanguageServer()

package/.eslintrc

@@ -1,29 +0,0 @@
-{
-  "root": true,
-  "extends": [
-    "eslint:recommended"
-  ],
-  "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
-  },
-  "env": {
-    "node": true,
-    "browser": true,
-    "es2024": true
-  },
-  "parserOptions": {
-    "sourceType": "module",
-    "ecmaVersion": "latest"
-  }
-}