Implement websocket API

Cargo.toml

@@ -100,7 +100,7 @@ exclude = [
     "crates/wasm-rquickjs/skeleton",
     "tmp"
 ]
-members = ["crates/wasi-logging", "crates/wasm-rquickjs"]
+members = ["crates/wasi-logging", "crates/wasm-rquickjs", "crates/golem-websocket"]
 
 [workspace.package]
 version = "0.0.0"

README.md

@@ -529,7 +529,7 @@ Requires the `http` feature flag. Client requests use `wasi:http` (TLS handled t
 - `node:_http_common` — `_checkIsHttpToken`, `_checkInvalidHeaderChar`
 - Supported features: keep-alive connections, chunked transfer encoding, content-length bodies, sequential request pipelining, idle connection cleanup
 
-**Not yet supported:** HTTP Upgrade/WebSocket, 1xx informational events, server-side timeout enforcement, `https.createServer()` / HTTPS server, client `lookup` / `autoSelectFamily` options.
+**Not yet supported:** HTTP Upgrade, 1xx informational events, server-side timeout enforcement, `https.createServer()` / HTTPS server, client `lookup` / `autoSelectFamily` options.
 
 </details>
 

crates/golem-websocket/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "golem-websocket"
+version = "0.0.2"
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+description = "Packages golem:websocket as a simple Rust crate"
+
+[dependencies]
+wit-bindgen-rt = { version = "0.42.1" }
+wit-bindgen = { version = "0.51.0", default-features = false, features = ["macros"] }
+wasip2 = "1.0"
+
+[package.metadata.component.target.dependencies]
+"golem:websocket" = { path = "wit/deps/golem-websocket" }

crates/golem-websocket/src/lib.rs

@@ -0,0 +1,15 @@
+#[allow(unsafe_op_in_unsafe_fn)]
+mod bindings {
+    wit_bindgen::generate!({
+        world: "golem-websocket",
+        path: "wit",
+        generate_all,
+        pub_export_macro: true,
+        default_bindings_module: "crate::bindings",
+        with: {
+            "wasi:io/poll@0.2.3": wasip2::io::poll,
+        },
+    });
+}
+
+pub use bindings::golem::websocket::client::{CloseInfo, Error, Message, WebsocketConnection};

crates/golem-websocket/wit/deps/golem-websocket/websocket.wit

@@ -0,0 +1,51 @@
+package golem:websocket@1.5.0;
+
+interface client {
+  use wasi:io/poll@0.2.3.{pollable};
+
+  variant error {
+    connection-failure(string),
+    send-failure(string),
+    receive-failure(string),
+    protocol-error(string),
+    closed(option<close-info>),
+    other(string),
+  }
+
+  record close-info {
+    code: u16,
+    reason: string,
+  }
+
+  /// A WebSocket message — text or binary
+  variant message {
+    text(string),
+    binary(list<u8>),
+  }
+
+  /// A WebSocket connection resource
+  resource websocket-connection {
+    /// Connect to a WebSocket server at the given URL (ws:// or wss://)
+    /// Optional headers for auth, subprotocols, etc.
+    connect: static func(
+      url: string,
+      headers: option<list<tuple<string, string>>>
+    ) -> result<websocket-connection, error>;
+
+    /// Send a message (text or binary)
+    send: func(message: message) -> result<_, error>;
+
+    /// Receive the next message (blocks until available)
+    receive: func() -> result<message, error>;
+
+    /// Receive the next message with a timeout in milliseconds.
+    /// Returns none if the timeout expires before a message arrives.
+    receive-with-timeout: func(timeout-ms: u64) -> result<option<message>, error>;
+
+    /// Send a close frame with optional code and reason
+    close: func(code: option<u16>, reason: option<string>) -> result<_, error>;
+
+    /// Returns a pollable that resolves when a message is available to read
+    subscribe: func() -> pollable;
+  }
+}

crates/golem-websocket/wit/deps/io/poll.wit

@@ -0,0 +1,47 @@
+package wasi:io@0.2.3;
+
+/// A poll API intended to let users wait for I/O events on multiple handles
+/// at once.
+@since(version = 0.2.0)
+interface poll {
+    /// `pollable` represents a single I/O event which may be ready, or not.
+    @since(version = 0.2.0)
+    resource pollable {
+
+      /// Return the readiness of a pollable. This function never blocks.
+      ///
+      /// Returns `true` when the pollable is ready, and `false` otherwise.
+      @since(version = 0.2.0)
+      ready: func() -> bool;
+
+      /// `block` returns immediately if the pollable is ready, and otherwise
+      /// blocks until ready.
+      ///
+      /// This function is equivalent to calling `poll.poll` on a list
+      /// containing only this pollable.
+      @since(version = 0.2.0)
+      block: func();
+    }
+
+    /// Poll for completion on a set of pollables.
+    ///
+    /// This function takes a list of pollables, which identify I/O sources of
+    /// interest, and waits until one or more of the events is ready for I/O.
+    ///
+    /// The result `list<u32>` contains one or more indices of handles in the
+    /// argument list that is ready for I/O.
+    ///
+    /// This function traps if either:
+    /// - the list is empty, or:
+    /// - the list contains more elements than can be indexed with a `u32` value.
+    ///
+    /// A timeout can be implemented by adding a pollable from the
+    /// wasi-clocks API to the list.
+    ///
+    /// This function does not return a `result`; polling in itself does not
+    /// do any I/O so it doesn't fail. If any of the I/O sources identified by
+    /// the pollables has an error, it is indicated by marking the source as
+    /// being ready for I/O.
+    @since(version = 0.2.0)
+    poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}

crates/golem-websocket/wit/golem-websocket.wit

@@ -0,0 +1,5 @@
+package golem-websocket-rust:golem-websocket;
+
+world golem-websocket {
+    import golem:websocket/client@1.5.0;
+}

crates/wasm-rquickjs/skeleton/Cargo.toml_

@@ -25,6 +25,7 @@ full-no-logging = ["lite", "node-http", "crypto", "zlib", "encoding", "crypto-fu
 # Individual capabilities
 fetch = ["dep:golem-wasi-http"]
 node-http = []
+
 logging = ["dep:wasi-logging"]
 encoding = ["dep:encoding_rs"]
 zlib = ["dep:flate2", "dep:crc32fast"]
@@ -52,7 +53,7 @@ crypto-full = [
 
 sqlite = ["dep:rusqlite"]
 timezone = ["dep:chrono-tz"]
-golem = ["normal", "dep:golem-rust"]
+golem = ["dep:golem-rust", "dep:golem-websocket"]
 
 [dependencies]
 # Core dependencies
@@ -121,7 +122,8 @@ wasi-logging = { version = "0.0.1", optional = true }
 rusqlite = { version = "0.38", default-features = false, features = ["bundled", "wasm32-wasi-vfs", "functions", "session", "backup", "serialize"], optional = true }
 
 # Golem
-golem-rust = { version = "1.7", default-features = false, optional = true }
+golem-rust = { git = "https://github.com/golemcloud/golem.git", branch = "main", default-features = false, optional = true }
+golem-websocket = { git = "https://github.com/golemcloud/wasm-rquickjs.git", rev = "2f8a2e468985dd13516c3c13603dbb8ea5ce9534", optional = true }
 
 # Patch rusqlite and libsqlite3-sys together for wasm32-wasi: the fork carries
 # both the serialize/deserialize flag typing fix and the session-enabled WASI

crates/wasm-rquickjs/skeleton/src/builtin/mod.rs

@@ -81,6 +81,8 @@ mod web_crypto {
     pub use super::web_crypto_lite::*;
 }
 
+#[cfg(feature = "golem")]
+mod websocket;
 mod webstreams;
 mod worker_threads;
 
@@ -260,7 +262,9 @@ pub fn add_module_resolvers(
     #[cfg(feature = "golem")]
     let resolver = resolver
         .with_module("__wasm_rquickjs_builtin/diagnostics_channel_native")
-        .with_module("__wasm_rquickjs_builtin/diagnostics_channel_golem");
+        .with_module("__wasm_rquickjs_builtin/diagnostics_channel_golem")
+        .with_module("__wasm_rquickjs_builtin/websocket_native")
+        .with_module("__wasm_rquickjs_builtin/websocket");
 
     internal::add_to_resolver(resolver)
 }
@@ -336,10 +340,15 @@ pub fn module_loader() -> (
         );
 
     #[cfg(feature = "golem")]
-    let native_loader = native_loader.with_module(
-        "__wasm_rquickjs_builtin/diagnostics_channel_native",
-        diagnostics_channel::js_native_module,
-    );
+    let native_loader = native_loader
+        .with_module(
+            "__wasm_rquickjs_builtin/diagnostics_channel_native",
+            diagnostics_channel::js_native_module,
+        )
+        .with_module(
+            "__wasm_rquickjs_builtin/websocket_native",
+            websocket::js_native_module,
+        );
 
     let builtin_loader = rquickjs::loader::BuiltinLoader::default()
         .with_module(
@@ -489,10 +498,12 @@ pub fn module_loader() -> (
         .with_module("node:sqlite", sqlite::SQLITE_JS);
 
     #[cfg(feature = "golem")]
-    let builtin_loader = builtin_loader.with_module(
-        "__wasm_rquickjs_builtin/diagnostics_channel_golem",
-        diagnostics_channel::DIAGNOSTICS_CHANNEL_GOLEM_JS,
-    );
+    let builtin_loader = builtin_loader
+        .with_module(
+            "__wasm_rquickjs_builtin/diagnostics_channel_golem",
+            diagnostics_channel::DIAGNOSTICS_CHANNEL_GOLEM_JS,
+        )
+        .with_module("__wasm_rquickjs_builtin/websocket", websocket::WEBSOCKET_JS);
 
     (native_loader, builtin_loader, internal::module_loader())
 }
@@ -524,6 +535,9 @@ pub fn wire_builtins() -> String {
     #[cfg(feature = "golem")]
     writeln!(result, "{}", diagnostics_channel::GOLEM_WIRE_JS).unwrap();
 
+    #[cfg(feature = "golem")]
+    writeln!(result, "{}", websocket::WIRE_JS).unwrap();
+
     result
 }
 

crates/wasm-rquickjs/skeleton/src/builtin/node_http.js

@@ -2635,9 +2635,18 @@ export function get(url, options, callback) {
     return req;
 }
 
+// ===== WebSocket re-exports (per Node.js convention) =====
+// These are lazily read from globalThis because the websocket WIRE_JS init script
+// sets them after module evaluation but before any user code runs.
+export const WebSocket = globalThis.WebSocket;
+export const WebSocketStream = globalThis.WebSocketStream;
+export const MessageEvent = globalThis.MessageEvent;
+export const CloseEvent = globalThis.CloseEvent;
+export const ErrorEvent = globalThis.ErrorEvent;
+
 // ===== Default export =====
 
-export default {
+const _default = {
     METHODS,
     STATUS_CODES,
     maxHeaderSize,
@@ -2654,3 +2663,12 @@ export default {
     request,
     get,
 };
+// Add WebSocket properties as lazy getters so they resolve after WIRE_JS runs
+Object.defineProperties(_default, {
+    WebSocket: { get() { return globalThis.WebSocket; }, enumerable: true },
+    WebSocketStream: { get() { return globalThis.WebSocketStream; }, enumerable: true },
+    MessageEvent: { get() { return globalThis.MessageEvent; }, enumerable: true },
+    CloseEvent: { get() { return globalThis.CloseEvent; }, enumerable: true },
+    ErrorEvent: { get() { return globalThis.ErrorEvent; }, enumerable: true },
+});
+export default _default;

crates/wasm-rquickjs/skeleton/src/builtin/node_http_disabled.js

@@ -35,11 +35,15 @@ export function createServer() { throw NOT_SUPPORTED_ERROR; }
 export function request() { throw NOT_SUPPORTED_ERROR; }
 export function get() { throw NOT_SUPPORTED_ERROR; }
 
+export const WebSocket = globalThis.WebSocket;
+export const WebSocketStream = globalThis.WebSocketStream;
+
 export default {
     METHODS, STATUS_CODES, maxHeaderSize,
     validateHeaderName, validateHeaderValue,
     Agent, globalAgent,
     ClientRequest, IncomingMessage,
     Server, ServerResponse,
     createServer, request, get,
+    WebSocket, WebSocketStream,
 };