@gjsify/ws 0.2.0

package/lib/esm/constants.js

@@ -0,0 +1,16 @@
+const BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+const EMPTY_BUFFER = new Uint8Array(0);
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+const kWebSocket = /* @__PURE__ */ Symbol("ws:kWebSocket");
+export {
+  BINARY_TYPES,
+  CLOSED,
+  CLOSING,
+  CONNECTING,
+  EMPTY_BUFFER,
+  OPEN,
+  kWebSocket
+};

package/lib/esm/index.js

@@ -0,0 +1,15 @@
+import { WebSocket } from "./websocket.js";
+import { WebSocketServer } from "./websocket-server.js";
+import { createWebSocketStream } from "./stream.js";
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocketServer;
+WebSocket.Server = WebSocketServer;
+WebSocket.createWebSocketStream = createWebSocketStream;
+var index_default = WebSocket;
+export {
+  WebSocketServer as Server,
+  WebSocket,
+  WebSocketServer,
+  createWebSocketStream,
+  index_default as default
+};

package/lib/esm/stream.js

@@ -0,0 +1,89 @@
+import { Duplex } from "node:stream";
+function emitClose(stream) {
+  stream.emit("close");
+}
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+function duplexOnError(err) {
+  this.removeListener("error", duplexOnError);
+  this.destroy();
+  if (this.listenerCount("error") === 0) {
+    this.emit("error", err);
+  }
+}
+function createWebSocketStream(ws, options = {}) {
+  let terminateOnDestroy = true;
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    writableObjectMode: false
+  });
+  ws.on("message", (msg, isBinary) => {
+    let data;
+    if (isBinary || duplex.readableObjectMode) {
+      data = msg;
+    } else {
+      data = typeof msg === "string" ? Buffer.from(msg) : msg;
+    }
+    if (!duplex.push(data) && typeof ws.pause === "function") ws.pause();
+  });
+  ws.once("error", (err) => {
+    if (duplex.destroyed) return;
+    terminateOnDestroy = false;
+    duplex.destroy(err);
+  });
+  ws.once("close", () => {
+    if (duplex.destroyed) return;
+    duplex.push(null);
+  });
+  duplex._destroy = function(err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+    let called = false;
+    ws.once("error", (e) => {
+      called = true;
+      callback(e);
+    });
+    ws.once("close", () => {
+      if (!called) callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+    if (terminateOnDestroy) ws.terminate();
+  };
+  duplex._final = function(callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once("open", () => duplex._final(callback));
+      return;
+    }
+    if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
+      callback();
+      return;
+    }
+    ws.once("close", callback);
+    ws.close();
+  };
+  duplex._read = function() {
+    if (typeof ws.resume === "function") ws.resume();
+  };
+  duplex._write = function(chunk, _encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once("open", () => duplex._write(chunk, _encoding, callback));
+      return;
+    }
+    ws.send(chunk, callback);
+  };
+  duplex.on("end", duplexOnEnd);
+  duplex.on("error", duplexOnError);
+  return duplex;
+}
+export {
+  createWebSocketStream
+};

package/lib/esm/websocket-server.js

@@ -0,0 +1,409 @@
+import { EventEmitter } from "@gjsify/events";
+import { Buffer } from "@gjsify/buffer";
+import { createHash } from "@gjsify/crypto";
+import Soup from "@girs/soup-3.0";
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+import { ensureMainLoop } from "@gjsify/utils";
+import { CLOSED, CLOSING, CONNECTING, OPEN } from "./constants.js";
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const WS_KEY_REGEX = /^[+/0-9A-Za-z]{22}==$/;
+class ServerSideWebSocket extends EventEmitter {
+  static CONNECTING = CONNECTING;
+  static OPEN = OPEN;
+  static CLOSING = CLOSING;
+  static CLOSED = CLOSED;
+  CONNECTING = CONNECTING;
+  OPEN = OPEN;
+  CLOSING = CLOSING;
+  CLOSED = CLOSED;
+  readyState = OPEN;
+  protocol = "";
+  extensions = "";
+  url = "";
+  _conn;
+  constructor(conn, url) {
+    super();
+    this._conn = conn;
+    this.url = url;
+    conn.connect("message", (_c, type, bytes) => {
+      const data = bytes.get_data();
+      if (type === Soup.WebsocketDataType.TEXT) {
+        const str = typeof data === "string" ? data : data ? new TextDecoder("utf-8").decode(data) : "";
+        this.emit("message", str, false);
+      } else {
+        const buf = data ? Buffer.from(data) : Buffer.alloc(0);
+        this.emit("message", buf, true);
+      }
+    });
+    conn.connect("closed", () => {
+      this.readyState = CLOSED;
+      const code = conn.get_close_code() || 1005;
+      const reason = conn.get_close_data() || "";
+      this.emit("close", code, Buffer.from(reason));
+    });
+    conn.connect("error", (_c, err) => {
+      this.emit("error", new Error(err.message));
+    });
+  }
+  send(data, optionsOrCb, cb) {
+    const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
+    try {
+      if (typeof data === "string") {
+        const bytes = new TextEncoder().encode(data);
+        this._conn.send_message(Soup.WebsocketDataType.TEXT, new GLib.Bytes(bytes));
+      } else {
+        let bytes;
+        if (Buffer.isBuffer(data)) {
+          const b = data;
+          bytes = new GLib.Bytes(new Uint8Array(b.buffer, b.byteOffset, b.byteLength));
+        } else if (data instanceof ArrayBuffer) {
+          bytes = new GLib.Bytes(new Uint8Array(data));
+        } else if (ArrayBuffer.isView(data)) {
+          const view = data;
+          bytes = new GLib.Bytes(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+        } else {
+          throw new TypeError("Unsupported send() payload type");
+        }
+        this._conn.send_message(Soup.WebsocketDataType.BINARY, bytes);
+      }
+      if (callback) queueMicrotask(() => callback());
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      if (callback) queueMicrotask(() => callback(e));
+      else queueMicrotask(() => this.emit("error", e));
+    }
+  }
+  close(code, reason) {
+    if (this.readyState === CLOSED || this.readyState === CLOSING) return;
+    this.readyState = CLOSING;
+    try {
+      const reasonStr = reason === void 0 ? null : Buffer.isBuffer(reason) ? reason.toString("utf8") : String(reason);
+      this._conn.close(code ?? 1e3, reasonStr);
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  terminate() {
+    if (this.readyState === CLOSED) return;
+    this.readyState = CLOSING;
+    try {
+      this._conn.close(1006, null);
+    } catch {
+    }
+  }
+}
+class WebSocketServer extends EventEmitter {
+  options;
+  clients = /* @__PURE__ */ new Set();
+  path;
+  _server = null;
+  _address = null;
+  constructor(options = {}, callback) {
+    super();
+    this.options = options;
+    this.path = options.path ?? "/";
+    if (options.noServer) {
+      if (options.port !== void 0 || options.server !== void 0) {
+        throw new Error(
+          "ws.WebSocketServer: { noServer: true } is mutually exclusive with port and server."
+        );
+      }
+      if (callback) this.once("listening", callback);
+      return;
+    }
+    if (options.port === void 0 && !options.server) {
+      throw new Error(
+        "ws.WebSocketServer requires either options.port or options.server on Gjs."
+      );
+    }
+    if (callback) this.once("listening", callback);
+    this._start(options);
+  }
+  // ── Private helpers ─────────────────────────────────────────────────────
+  _buildVerifyClientInfo(msg) {
+    const reqHeaders = msg.get_request_headers();
+    const headers = {};
+    reqHeaders.foreach((name, value) => {
+      const lower = name.toLowerCase();
+      const existing = headers[lower];
+      if (existing === void 0) headers[lower] = value;
+      else if (Array.isArray(existing)) existing.push(value);
+      else headers[lower] = [existing, value];
+    });
+    const uri = msg.get_uri();
+    const urlPath = uri.get_path() ?? "/";
+    const query = uri.get_query();
+    const url = query ? `${urlPath}?${query}` : urlPath;
+    const remoteHost = msg.get_remote_host() ?? "127.0.0.1";
+    const remoteAddr = msg.get_remote_address();
+    const remotePort = remoteAddr instanceof Gio.InetSocketAddress ? remoteAddr.get_port() : 0;
+    return {
+      origin: headers["origin"] ?? "",
+      secure: false,
+      req: {
+        method: msg.get_method(),
+        url,
+        headers,
+        socket: { remoteAddress: remoteHost, remotePort }
+      }
+    };
+  }
+  /** Register add_handler (verifyClient) + add_websocket_handler on soupServer.
+   *  The verifyClient add_handler MUST be registered before add_websocket_handler —
+   *  Soup processes normal handlers before websocket handlers; setting a status code
+   *  in add_handler prevents the websocket handler from firing (HTTP-level rejection).
+   *  Only register add_handler when verifyClient is provided — a no-op handler on the
+   *  same path as an existing http.Server catch-all can interfere with Soup's routing. */
+  _setupHandlers(soupServer, options) {
+    if (options.verifyClient) {
+      const vc = options.verifyClient;
+      soupServer.add_handler(this.path, (_srv, msg) => {
+        const reqHeaders = msg.get_request_headers();
+        const upgrade = (reqHeaders.get_one("Upgrade") ?? "").toLowerCase();
+        if (upgrade !== "websocket") return;
+        const info = this._buildVerifyClientInfo(msg);
+        if (vc.length >= 2) {
+          msg.pause();
+          vc(info, (result, code = 401) => {
+            if (!result) msg.set_status(code, null);
+            msg.unpause();
+          });
+        } else {
+          const ok = vc(info);
+          if (!ok) msg.set_status(401, null);
+        }
+      });
+    }
+    soupServer.add_websocket_handler(
+      this.path,
+      null,
+      // origin filter — accept any
+      null,
+      // protocols — Soup accepts all; handleProtocols selects after connect
+      (_server, msg, _path, conn) => {
+        const url = msg.get_uri()?.to_string() ?? this.path;
+        const ws = new ServerSideWebSocket(conn, url);
+        if (options.handleProtocols) {
+          const raw = msg.get_request_headers().get_one("Sec-WebSocket-Protocol") ?? "";
+          const offered = new Set(
+            raw.split(",").map((s) => s.trim()).filter(Boolean)
+          );
+          const req = this._buildVerifyClientInfo(msg).req;
+          const selected = options.handleProtocols(offered, req);
+          if (selected) ws.protocol = selected;
+        }
+        if (options.clientTracking !== false) {
+          this.clients.add(ws);
+          ws.on("close", () => this.clients.delete(ws));
+        }
+        this.emit("connection", ws, msg);
+      }
+    );
+  }
+  _start(options) {
+    try {
+      if (options.server) {
+        const httpServer = options.server;
+        const soupServer = httpServer.soupServer;
+        if (!soupServer) {
+          throw new Error(
+            "options.server has no active Soup.Server. Ensure httpServer.listen() was called before creating WebSocketServer."
+          );
+        }
+        this._server = soupServer;
+        this._setupHandlers(soupServer, options);
+        ensureMainLoop();
+        const addr = httpServer.address();
+        if (addr) this._address = { address: addr.address, family: addr.family, port: addr.port };
+        queueMicrotask(() => this.emit("listening"));
+      } else {
+        this._server = new Soup.Server({});
+        this._setupHandlers(this._server, options);
+        const host = options.host ?? "0.0.0.0";
+        const port = options.port;
+        if (host === "127.0.0.1" || host === "localhost") {
+          this._server.listen_local(port, Soup.ServerListenOptions.IPV4_ONLY);
+        } else if (host === "::1") {
+          this._server.listen_local(port, Soup.ServerListenOptions.IPV6_ONLY);
+        } else {
+          this._server.listen_all(port, 0);
+        }
+        const listeners = this._server.get_listeners();
+        let actualPort = port;
+        if (listeners && listeners.length > 0) {
+          const addr = listeners[0].get_local_address();
+          if (addr && typeof addr.get_port === "function") actualPort = addr.get_port();
+        }
+        ensureMainLoop();
+        this._address = { address: host, family: "IPv4", port: actualPort };
+        queueMicrotask(() => this.emit("listening"));
+      }
+    } catch (err) {
+      queueMicrotask(() => this.emit("error", err instanceof Error ? err : new Error(String(err))));
+    }
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  address() {
+    return this._address;
+  }
+  close(callback) {
+    try {
+      for (const ws of this.clients) ws.close();
+      this.clients.clear();
+      if (!this.options.server) {
+        this._server?.disconnect();
+      }
+      this._server = null;
+      this._address = null;
+      this.emit("close");
+      if (callback) queueMicrotask(() => callback());
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      this.emit("error", e);
+      if (callback) queueMicrotask(() => callback(e));
+    }
+  }
+  /** Manual WebSocket upgrade — matches npm ws semantics exactly.
+   *  The caller intercepts 'upgrade' on an http.Server (typically with
+   *  { noServer: true } on this WebSocketServer) and passes the raw
+   *  IncomingMessage + net.Socket + head buffer here.
+   *
+   *  Internally: validates headers, runs verifyClient, computes
+   *  Sec-WebSocket-Accept, emits 'headers' (mutable array), writes the 101
+   *  response via socket.write(), then creates Soup.WebsocketConnection from
+   *  the underlying IOStream and calls cb(ws, req). */
+  handleUpgrade(req, socket, _head, cb) {
+    if (!this._validateUpgradeHeaders(req, socket)) return;
+    const key = req.headers?.["sec-websocket-key"] ?? "";
+    const doUpgrade = () => this._completeUpgrade(req, socket, key, cb);
+    if (this.options.verifyClient) {
+      const vc = this.options.verifyClient;
+      const info = this._buildVerifyClientInfoFromReq(req);
+      if (vc.length >= 2) {
+        vc(info, (result, code = 401) => {
+          if (!result) {
+            this._abortHandshake(socket, code);
+            return;
+          }
+          doUpgrade();
+        });
+        return;
+      }
+      if (!vc(info)) {
+        this._abortHandshake(socket, 401);
+        return;
+      }
+    }
+    doUpgrade();
+  }
+  shouldHandle(req) {
+    if (this.path === "/") return true;
+    const url = req?.url ?? "/";
+    return url === this.path || url.startsWith(this.path + "?") || url.startsWith(this.path + "/");
+  }
+  // ── handleUpgrade helpers ───────────────────────────────────────────────
+  _validateUpgradeHeaders(req, socket) {
+    const h = req.headers ?? {};
+    if (req.method !== "GET") {
+      this._abortHandshake(socket, 405);
+      return false;
+    }
+    if ((h["upgrade"] ?? "").toLowerCase() !== "websocket") {
+      this._abortHandshake(socket, 400);
+      return false;
+    }
+    if (!WS_KEY_REGEX.test(h["sec-websocket-key"] ?? "")) {
+      this._abortHandshake(socket, 400);
+      return false;
+    }
+    const ver = Number(h["sec-websocket-version"] ?? "0");
+    if (ver !== 13 && ver !== 8) {
+      this._abortHandshake(socket, 426);
+      return false;
+    }
+    if (!this.shouldHandle(req)) {
+      this._abortHandshake(socket, 400);
+      return false;
+    }
+    return true;
+  }
+  _completeUpgrade(req, socket, key, cb) {
+    const digest = createHash("sha1").update(key + WS_GUID).digest("base64");
+    const responseHeaders = [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+    let selectedProtocol = null;
+    if (this.options.handleProtocols) {
+      const raw = req.headers?.["sec-websocket-protocol"] ?? "";
+      const offered = new Set(raw.split(",").map((s) => s.trim()).filter(Boolean));
+      const sel = this.options.handleProtocols(offered, this._buildVerifyClientInfoFromReq(req).req);
+      if (sel) {
+        selectedProtocol = sel;
+        responseHeaders.push(`Sec-WebSocket-Protocol: ${sel}`);
+      }
+    }
+    this.emit("headers", responseHeaders, req);
+    const responseStr = responseHeaders.join("\r\n") + "\r\n\r\n";
+    socket.write(responseStr, () => {
+      const ioStream = typeof socket._releaseIOStream === "function" ? socket._releaseIOStream() : null;
+      if (!ioStream) {
+        socket.destroy?.();
+        return;
+      }
+      const rawUrl = req.url ?? "/";
+      const uri = GLib.Uri.parse(`ws://localhost${rawUrl}`, GLib.UriFlags.NONE);
+      const conn = Soup.WebsocketConnection["new"](
+        ioStream,
+        uri,
+        Soup.WebsocketConnectionType.SERVER,
+        null,
+        selectedProtocol,
+        []
+      );
+      const ws = new ServerSideWebSocket(conn, rawUrl);
+      if (selectedProtocol) ws.protocol = selectedProtocol;
+      if (this.options.clientTracking !== false) {
+        this.clients.add(ws);
+        ws.on("close", () => this.clients.delete(ws));
+      }
+      cb(ws, req);
+    });
+  }
+  _abortHandshake(socket, code) {
+    const statusTexts = {
+      400: "Bad Request",
+      401: "Unauthorized",
+      403: "Forbidden",
+      405: "Method Not Allowed",
+      426: "Upgrade Required"
+    };
+    const msg = statusTexts[code] ?? "Error";
+    socket.write?.(`HTTP/1.1 ${code} ${msg}\r
+Content-Length: 0\r
+Connection: close\r
+\r
+`, () => {
+      socket.destroy?.();
+    });
+  }
+  _buildVerifyClientInfoFromReq(req) {
+    const h = req.headers ?? {};
+    return {
+      origin: h["origin"] ?? "",
+      secure: false,
+      req: {
+        method: req.method ?? "GET",
+        url: req.url ?? "/",
+        headers: h,
+        socket: { remoteAddress: req.socket?.remoteAddress ?? "127.0.0.1", remotePort: req.socket?.remotePort ?? 0 }
+      }
+    };
+  }
+}
+export {
+  WebSocketServer
+};