wasmnet 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# wasmnet
+
+Browser client for [wasmnet](https://github.com/anistark/wasmnet) — a networking proxy that bridges WASI socket APIs to real TCP via WebSocket.
+
+## Install
+
+```sh
+npm install wasmnet
+```
+
+## Usage
+
+```javascript
+import { WasmnetClient } from 'wasmnet';
+
+const client = new WasmnetClient('ws://localhost:9000');
+await client.ready();
+
+// Outbound TCP connection
+const id = await client.connect('api.example.com', 443);
+
+client.onData(id, (data) => {
+  console.log('received:', new TextDecoder().decode(data));
+});
+
+client.onClose(id, () => {
+  console.log('connection closed');
+});
+
+client.send(id, 'GET / HTTP/1.1\r\nHost: api.example.com\r\n\r\n');
+
+// Inbound TCP (bind a port)
+const listener = await client.bind('0.0.0.0', 3000);
+console.log(`listening on port ${listener.port}`);
+
+client.onAccept(listener.id, (connId, remote) => {
+  console.log(`accepted connection from ${remote}`);
+  client.onData(connId, (data) => {
+    client.send(connId, data); // echo
+  });
+});
+
+// Cleanup
+client.close(id);
+client.disconnect();
+```
+
+## API
+
+### `new WasmnetClient(url: string)`
+
+Creates a client connecting to the wasmnet server at the given WebSocket URL.
+
+### `ready(): Promise<void>`
+
+Resolves when the WebSocket connection is established.
+
+### `connect(addr: string, port: number): Promise<number>`
+
+Opens an outbound TCP connection. Returns the socket ID.
+
+### `bind(addr: string, port: number): Promise<{ id: number, port: number }>`
+
+Binds a TCP listener. Returns the listener ID and actual bound port.
+
+### `listen(id: number, backlog?: number): void`
+
+Starts accepting connections on a bound listener.
+
+### `send(id: number, data: string | Uint8Array | ArrayBuffer): void`
+
+Sends data on a socket. Strings are UTF-8 encoded, binary data is sent as-is.
+
+### `close(id: number): void`
+
+Closes a socket or listener.
+
+### `onData(id: number, callback: (data: Uint8Array) => void): void`
+
+Registers a data handler. Any buffered data is flushed immediately.
+
+### `onClose(id: number, callback: () => void): void`
+
+Registers a close handler.
+
+### `onAccept(id: number, callback: (connId: number, remote: string) => void): void`
+
+Registers an accept handler for a listener.
+
+### `disconnect(): void`
+
+Closes the WebSocket connection and all sockets.
+
+## MIT License

package/dist/wasmnet-client.d.ts

@@ -0,0 +1,23 @@
+export interface ListenResult {
+  id: number;
+  port: number;
+}
+
+export type DataCallback = (data: Uint8Array) => void;
+export type CloseCallback = () => void;
+export type AcceptCallback = (connId: number, remote: string) => void;
+
+export class WasmnetClient {
+  constructor(url: string);
+
+  ready(): Promise<void>;
+  connect(addr: string, port: number): Promise<number>;
+  bind(addr: string, port: number): Promise<ListenResult>;
+  listen(id: number, backlog?: number): void;
+  send(id: number, data: string | Uint8Array | ArrayBuffer): void;
+  close(id: number): void;
+  onData(id: number, callback: DataCallback): void;
+  onClose(id: number, callback: CloseCallback): void;
+  onAccept(id: number, callback: AcceptCallback): void;
+  disconnect(): void;
+}

package/dist/wasmnet-client.js

@@ -0,0 +1,139 @@
+export class WasmnetClient {
+  constructor(url) {
+    this.ws = new WebSocket(url);
+    this.sockets = new Map();
+    this.nextId = 1;
+    this._ready = new Promise((resolve, reject) => {
+      this.ws.onopen = () => resolve();
+      this.ws.onerror = (e) => reject(e);
+    });
+    this.ws.onmessage = (e) => this._handleEvent(JSON.parse(e.data));
+    this.ws.onclose = () => this._handleClose();
+  }
+
+  async ready() {
+    return this._ready;
+  }
+
+  connect(addr, port) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.sockets.set(id, { resolve, reject, buffer: [], onData: null, onClose: null });
+      this._send({ op: "connect", id, addr, port });
+    });
+  }
+
+  bind(addr, port) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.sockets.set(id, { resolve, reject, onAccept: null });
+      this._send({ op: "bind", id, addr, port });
+    });
+  }
+
+  listen(id, backlog = 128) {
+    this._send({ op: "listen", id, backlog });
+  }
+
+  send(id, data) {
+    const encoded = typeof data === "string" ? btoa(data) : this._encodeBinary(data);
+    this._send({ op: "send", id, data: encoded });
+  }
+
+  close(id) {
+    this._send({ op: "close", id });
+    this.sockets.delete(id);
+  }
+
+  onData(id, callback) {
+    const sock = this.sockets.get(id);
+    if (!sock) return;
+    sock.onData = callback;
+    for (const buffered of sock.buffer) {
+      callback(buffered);
+    }
+    sock.buffer = [];
+  }
+
+  onClose(id, callback) {
+    const sock = this.sockets.get(id);
+    if (sock) sock.onClose = callback;
+  }
+
+  onAccept(id, callback) {
+    const sock = this.sockets.get(id);
+    if (sock) sock.onAccept = callback;
+  }
+
+  disconnect() {
+    this.ws.close();
+  }
+
+  _send(msg) {
+    this.ws.send(JSON.stringify(msg));
+  }
+
+  _encodeBinary(data) {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+
+  _decodeBinary(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+
+  _handleEvent(ev) {
+    const sock = this.sockets.get(ev.id);
+    if (!sock) return;
+
+    switch (ev.ev) {
+      case "connected":
+        sock.resolve(ev.id);
+        break;
+      case "listening":
+        sock.resolve({ id: ev.id, port: ev.port });
+        break;
+      case "data": {
+        const decoded = this._decodeBinary(ev.data);
+        if (sock.onData) {
+          sock.onData(decoded);
+        } else {
+          sock.buffer.push(decoded);
+        }
+        break;
+      }
+      case "accepted":
+        this.sockets.set(ev.conn_id, { buffer: [], onData: null, onClose: null });
+        sock.onAccept?.(ev.conn_id, ev.remote);
+        break;
+      case "closed":
+        sock.onClose?.();
+        this.sockets.delete(ev.id);
+        break;
+      case "error":
+        sock.reject?.(new Error(ev.msg));
+        this.sockets.delete(ev.id);
+        break;
+      case "denied":
+        sock.reject?.(new Error(ev.msg));
+        this.sockets.delete(ev.id);
+        break;
+    }
+  }
+
+  _handleClose() {
+    for (const [id, sock] of this.sockets) {
+      sock.onClose?.();
+    }
+    this.sockets.clear();
+  }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "wasmnet",
+  "version": "0.1.0",
+  "description": "Browser client for wasmnet — networking proxy for WASM",
+  "type": "module",
+  "main": "dist/wasmnet-client.js",
+  "module": "dist/wasmnet-client.js",
+  "types": "dist/wasmnet-client.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/wasmnet-client.js",
+      "types": "./dist/wasmnet-client.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "mkdir -p dist && cp wasmnet-client.js dist/ && cp wasmnet-client.d.ts dist/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "wasm",
+    "wasi",
+    "websocket",
+    "networking",
+    "proxy",
+    "tcp"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anistark/wasmnet",
+    "directory": "client"
+  },
+  "homepage": "https://github.com/anistark/wasmnet#readme"
+}