node-opcua-client-browser 2.177.0

package/dist/uacp.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @module node-opcua-client-browser
+ * @internal
+ *
+ * UACP primitives usable in the browser.
+ *
+ * These are thin re-exports of the byte-level encoders/decoders from
+ * `node-opcua-transport`. Those modules are pure-JS (only `node:events` is
+ * pulled in, which Vite polyfills automatically) and are therefore safe to
+ * bundle for the browser. Consolidating them here gives us a single point of
+ * audit if a future release of `node-opcua-transport` introduces a Node-only
+ * import.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRawMessageHeader = exports.packTcpMessage = exports.TCPErrorMessage = exports.HelloMessage = exports.AcknowledgeMessage = void 0;
+var node_opcua_transport_1 = require("node-opcua-transport");
+Object.defineProperty(exports, "AcknowledgeMessage", { enumerable: true, get: function () { return node_opcua_transport_1.AcknowledgeMessage; } });
+Object.defineProperty(exports, "HelloMessage", { enumerable: true, get: function () { return node_opcua_transport_1.HelloMessage; } });
+Object.defineProperty(exports, "TCPErrorMessage", { enumerable: true, get: function () { return node_opcua_transport_1.TCPErrorMessage; } });
+Object.defineProperty(exports, "packTcpMessage", { enumerable: true, get: function () { return node_opcua_transport_1.packTcpMessage; } });
+Object.defineProperty(exports, "readRawMessageHeader", { enumerable: true, get: function () { return node_opcua_transport_1.readRawMessageHeader; } });
+//# sourceMappingURL=uacp.js.map

package/dist/uacp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uacp.js","sourceRoot":"","sources":["../source/uacp.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAEH,6DAO8B;AAN1B,0HAAA,kBAAkB,OAAA;AAClB,oHAAA,YAAY,OAAA;AACZ,uHAAA,eAAe,OAAA;AACf,sHAAA,cAAc,OAAA;AACd,4HAAA,oBAAoB,OAAA"}

package/dist/ws_socket_adapter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @module node-opcua-client-browser
+ * @internal
+ *
+ * WebSocket → {@link ISocketLike} adapter.
+ *
+ * {@link TCP_transport} in `node-opcua-transport` expects an `ISocketLike` that
+ * emits `data`, `close`, `end`, `error`, `timeout` events and provides
+ * `write`, `end`, `destroy`, `setKeepAlive`, `setNoDelay`, `setTimeout`.
+ *
+ * This adapter turns a browser `WebSocket` (or the `ws` package used during
+ * unit tests) into that shape so the full HEL/ACK + chunk-assembly machinery
+ * in `TCP_transport` can be reused without change.
+ *
+ * Framing per OPC UA Part 6 §7.5: each outgoing UACP chunk is sent as exactly
+ * one binary WebSocket message. Incoming binary messages are concatenated via
+ * the `TCP_transport` packet-assembler, so even if a peer (e.g. `websockify`)
+ * splits a chunk across multiple frames, the assembler re-combines them.
+ * Text frames are ignored with a warning.
+ */
+import { EventEmitter } from "events";
+import type { ISocketLike } from "node-opcua-transport";
+/**
+ * Minimal structural type that matches both the browser `WebSocket` global and
+ * the `ws` package's Node implementation.
+ */
+export interface WebSocketLike {
+    readonly readyState: number;
+    binaryType: string;
+    send(data: ArrayBuffer | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((this: WebSocketLike, ev: unknown) => void) | null;
+    onclose: ((this: WebSocketLike, ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+    onerror: ((this: WebSocketLike, ev: unknown) => void) | null;
+    onmessage: ((this: WebSocketLike, ev: {
+        data: unknown;
+    }) => void) | null;
+}
+/**
+ * Wrap a {@link WebSocketLike} as an {@link ISocketLike}. The returned socket
+ * forwards `data` events once the WS is open, and cleans up the WS listeners
+ * on `destroy` or `end`.
+ *
+ * The WebSocket must already be instantiated (i.e. `new WebSocket(url, protocols)`).
+ * The caller drives this by the time `_install_socket` is called; we just bind.
+ */
+export declare class WsSocketAdapter extends EventEmitter implements ISocketLike {
+    private readonly ws;
+    remoteAddress?: string;
+    remotePort?: number;
+    destroyed: boolean;
+    private _timeoutHandle;
+    private _timeoutMs;
+    private _timeoutCb;
+    constructor(ws: WebSocketLike, url?: string);
+    write(data: string | Buffer, callback?: (err?: Error | null) => undefined | undefined): void;
+    end(): void;
+    destroy(_err?: Error): void;
+    setKeepAlive(_enable?: boolean, _initialDelay?: number): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    private _resetTimeout;
+    private _clearTimeout;
+}

package/dist/ws_socket_adapter.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * @module node-opcua-client-browser
+ * @internal
+ *
+ * WebSocket → {@link ISocketLike} adapter.
+ *
+ * {@link TCP_transport} in `node-opcua-transport` expects an `ISocketLike` that
+ * emits `data`, `close`, `end`, `error`, `timeout` events and provides
+ * `write`, `end`, `destroy`, `setKeepAlive`, `setNoDelay`, `setTimeout`.
+ *
+ * This adapter turns a browser `WebSocket` (or the `ws` package used during
+ * unit tests) into that shape so the full HEL/ACK + chunk-assembly machinery
+ * in `TCP_transport` can be reused without change.
+ *
+ * Framing per OPC UA Part 6 §7.5: each outgoing UACP chunk is sent as exactly
+ * one binary WebSocket message. Incoming binary messages are concatenated via
+ * the `TCP_transport` packet-assembler, so even if a peer (e.g. `websockify`)
+ * splits a chunk across multiple frames, the assembler re-combines them.
+ * Text frames are ignored with a warning.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsSocketAdapter = void 0;
+const events_1 = require("events");
+// WebSocket readyState constants (avoid importing the DOM lib to stay Node-side compatible)
+const WS_OPEN = 1;
+const WS_CLOSING = 2;
+const WS_CLOSED = 3;
+function toBuffer(data) {
+    if (!data)
+        return null;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data))
+        return data;
+    if (data instanceof ArrayBuffer)
+        return Buffer.from(new Uint8Array(data));
+    if (ArrayBuffer.isView(data)) {
+        const view = data;
+        return Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+    }
+    // Blob path: the transport's HEL/ACK uses `binaryType = "arraybuffer"`,
+    // so this should never hit. Fail loud if it does.
+    return null;
+}
+/**
+ * Wrap a {@link WebSocketLike} as an {@link ISocketLike}. The returned socket
+ * forwards `data` events once the WS is open, and cleans up the WS listeners
+ * on `destroy` or `end`.
+ *
+ * The WebSocket must already be instantiated (i.e. `new WebSocket(url, protocols)`).
+ * The caller drives this by the time `_install_socket` is called; we just bind.
+ */
+class WsSocketAdapter extends events_1.EventEmitter {
+    ws;
+    remoteAddress;
+    remotePort;
+    destroyed = false;
+    _timeoutHandle = null;
+    _timeoutMs = 0;
+    _timeoutCb = null;
+    constructor(ws, url) {
+        super();
+        this.ws = ws;
+        if (url) {
+            try {
+                const u = new URL(url);
+                this.remoteAddress = u.hostname;
+                this.remotePort = u.port ? Number(u.port) : undefined;
+            }
+            catch {
+                /* ignore – URL parse already happened in connect() */
+            }
+        }
+        ws.binaryType = "arraybuffer";
+        const emitError = (err) => {
+            this.emit("error", err);
+        };
+        ws.onopen = () => {
+            this.emit("connect");
+        };
+        ws.onmessage = (ev) => {
+            // Reset inactivity timer if any
+            this._resetTimeout();
+            const buf = toBuffer(ev.data);
+            if (!buf) {
+                // Text frame or unknown type: ignore with a warning, per spec
+                // eslint-disable-next-line no-console
+                console.warn("[ClientWS_transport] ignoring non-binary WebSocket frame");
+                return;
+            }
+            this.emit("data", buf);
+        };
+        ws.onerror = () => {
+            // Browser WebSocket errors carry no useful detail. Translate into a
+            // generic Error so downstream log messages still make sense.
+            emitError(new Error("WebSocket error"));
+        };
+        ws.onclose = (ev) => {
+            this._clearTimeout();
+            // `hadError` is best-effort: anything other than 1000 (normal) is
+            // treated as an error path.
+            const hadError = !!ev && typeof ev.code === "number" && ev.code !== 1000;
+            this.emit("end");
+            this.emit("close", hadError);
+        };
+    }
+    write(data, callback) {
+        if (this.destroyed || this.ws.readyState >= WS_CLOSING) {
+            callback?.(new Error("WebSocket is not open"));
+            return;
+        }
+        try {
+            if (typeof data === "string") {
+                // UACP chunks are always binary; if we somehow got a string,
+                // encode to UTF-8.
+                this.ws.send(new TextEncoder().encode(data));
+            }
+            else {
+                // Send as ArrayBufferView so the WS layer keeps it as one binary frame.
+                const u8 = data instanceof Uint8Array ? data : new Uint8Array(data);
+                // `send()` accepts ArrayBuffer or ArrayBufferView; use the view so the
+                // underlying buffer isn't copied unnecessarily.
+                this.ws.send(u8);
+            }
+            callback?.();
+        }
+        catch (err) {
+            callback?.(err);
+        }
+    }
+    end() {
+        this._clearTimeout();
+        if (this.ws.readyState === WS_OPEN) {
+            try {
+                this.ws.close(1000, "normal closure");
+            }
+            catch {
+                /* swallow */
+            }
+        }
+    }
+    destroy(_err) {
+        this.destroyed = true;
+        this._clearTimeout();
+        if (this.ws.readyState < WS_CLOSED) {
+            try {
+                this.ws.close(1001, "going away");
+            }
+            catch {
+                /* swallow */
+            }
+        }
+        // Detach handlers so no late events fire into a destroyed transport.
+        try {
+            this.ws.onopen = null;
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            this.ws.onmessage = null;
+        }
+        catch {
+            /* swallow */
+        }
+    }
+    // These three are no-ops for WebSocket – keep-alive and nodelay are handled
+    // by the browser / underlying TCP stack; we expose them so TCP_transport's
+    // setup sequence runs unchanged.
+    setKeepAlive(_enable, _initialDelay) {
+        return this;
+    }
+    setNoDelay(_noDelay) {
+        return this;
+    }
+    setTimeout(timeout, callback) {
+        this._timeoutMs = timeout;
+        this._timeoutCb = callback ?? null;
+        this._resetTimeout();
+        return this;
+    }
+    _resetTimeout() {
+        this._clearTimeout();
+        if (this._timeoutMs > 0 && this._timeoutCb) {
+            const cb = this._timeoutCb;
+            this._timeoutHandle = setTimeout(() => {
+                this.emit("timeout");
+                cb();
+            }, this._timeoutMs);
+        }
+    }
+    _clearTimeout() {
+        if (this._timeoutHandle !== null) {
+            clearTimeout(this._timeoutHandle);
+            this._timeoutHandle = null;
+        }
+    }
+}
+exports.WsSocketAdapter = WsSocketAdapter;
+//# sourceMappingURL=ws_socket_adapter.js.map

package/dist/ws_socket_adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws_socket_adapter.js","sourceRoot":"","sources":["../source/ws_socket_adapter.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+    "name": "node-opcua-client-browser",
+    "version": "2.177.0",
+    "description": "OPC UA SDK - browser WebSocket client (opc.ws / opc.wss)",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "browser": "./dist-esm/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "browser": "./dist-esm/index.js",
+            "import": "./dist-esm/index.js",
+            "require": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "sideEffects": false,
+    "scripts": {
+        "build": "tsc -b && tsc -p tsconfig.esm.json",
+        "build:test-page": "node build-test-page.mjs",
+        "lint": "eslint source test",
+        "test:unit": "mocha",
+        "test:e2e": "playwright test",
+        "test": "pnpm test:unit && pnpm test:e2e",
+        "test:check": "tsc --noEmit -p test/tsconfig.json",
+        "clean": "npx rimraf -g node_modules dist dist-esm test/page/dist *.tsbuildinfo test-results playwright-report"
+    },
+    "dependencies": {
+        "node-opcua-assert": "2.175.6",
+        "node-opcua-client": "2.177.0",
+        "node-opcua-common": "2.177.0",
+        "node-opcua-crypto": "5.5.0",
+        "node-opcua-debug": "2.175.6",
+        "node-opcua-status-code": "2.176.0",
+        "node-opcua-transport": "2.177.0"
+    },
+    "devDependencies": {
+        "@playwright/test": "^1.62.1",
+        "@types/ws": "^8.18.1",
+        "buffer": "^6.0.3",
+        "esbuild": "^0.28.2",
+        "events": "^3.3.0",
+        "node-opcua-leak-detector": "2.175.6",
+        "process": "^0.11.10",
+        "util": "^0.12.5",
+        "ws": "^8.21.3"
+    },
+    "author": "Sterfive SAS",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/node-opcua/node-opcua.git"
+    },
+    "keywords": [
+        "OPCUA",
+        "opcua",
+        "browser",
+        "websocket",
+        "wsopc-ua",
+        "opc.ws",
+        "opc.wss"
+    ],
+    "homepage": "http://node-opcua.github.io/",
+    "files": [
+        "dist",
+        "dist-esm",
+        "source"
+    ],
+    "gitHead": "064029878247adf2fa5d14a8124e1930431e2428"
+}

package/source/client_ws_transport.ts

@@ -0,0 +1,227 @@
+/**
+ * @module node-opcua-client-browser
+ *
+ * `ClientWS_transport` — OPC UA WebSocket client transport (Part 6 §7.5).
+ *
+ * Subclasses `ClientTCP_transport` and reuses its HEL/ACK + chunk-reassembly
+ * machinery unchanged. The only swap is the socket-creation step: instead of
+ * opening a TCP connection, we open a `WebSocket` and hand a
+ * {@link WsSocketAdapter} to `TCP_transport._install_socket`.
+ *
+ * OPC UA WebSocket framing:
+ *   - One UACP chunk per outgoing binary WebSocket frame (handled naturally —
+ *     each `write(chunk)` call invokes `ws.send(chunk)` once).
+ *   - Incoming bytes are fed into `TCP_transport`'s packet-assembler, which
+ *     re-combines split chunks.
+ *   - Subprotocol `opcua+uacp` is requested on the handshake. If the server
+ *     echoes it back we record that; if not (common with a `websockify`
+ *     bridge) we continue without failing — browsers still accept the
+ *     connection provided the server's bytes are valid UACP.
+ */
+
+/* global WebSocket */
+
+import { assert } from "node-opcua-assert";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import type { ErrorCallback } from "node-opcua-status-code";
+import {
+    ClientTransportBase,
+    type IClientTransport,
+    type IClientTransportFactory,
+    type ISocketLike,
+    type TransportSettingsOptions
+} from "node-opcua-transport";
+
+import { type WebSocketLike, WsSocketAdapter } from "./ws_socket_adapter";
+
+const debugLog = make_debugLog("ClientWS_transport");
+const warningLog = make_warningLog("ClientWS_transport");
+const doDebug = checkDebugFlag("ClientWS_transport");
+
+/** WebSocket subprotocol name defined by OPC UA Part 6 §7.5 */
+export const OPCUA_UACP_SUBPROTOCOL = "opcua+uacp";
+
+/**
+ * A tiny WebSocket-constructor type. In the browser this is `globalThis.WebSocket`;
+ * in Node-side unit tests this is the `ws` package's `default` export. Either works.
+ */
+export type WebSocketConstructor = new (url: string, protocols?: string | string[]) => WebSocketLike;
+
+/** Options specific to the browser WebSocket transport. */
+export interface ClientWSTransportOptions extends TransportSettingsOptions {
+    /**
+     * The WebSocket constructor to use. Defaults to `globalThis.WebSocket`.
+     * Override this from Node-side unit tests to inject the `ws` package.
+     */
+    webSocketCtor?: WebSocketConstructor;
+
+    /**
+     * When `true`, `connect()` fails if the peer does not echo back the
+     * `opcua+uacp` subprotocol on the WebSocket opening handshake. Defaults to
+     * `false` because `websockify` bridges do not negotiate subprotocols; the
+     * OPC UA bytes that follow will fail the HEL/ACK step anyway if the peer
+     * isn't actually speaking UACP.
+     */
+    strictSubprotocol?: boolean;
+}
+
+/**
+ * Parsed endpoint URL, normalised for the browser `WebSocket` constructor.
+ */
+export interface ParsedWsEndpoint {
+    /** The URL to pass to `new WebSocket(url, …)` — always starts with `ws://` or `wss://`. */
+    wsUrl: string;
+    /** `true` if the original URL used `opc.wss://` or `wss://`. */
+    secure: boolean;
+}
+
+/**
+ * Parse and normalise an OPC UA WebSocket endpoint URL. Accepts all four
+ * forms: `opc.ws://`, `opc.wss://`, `ws://`, `wss://`. Anything else throws.
+ *
+ * @throws {Error} if the scheme is not one of the four accepted forms.
+ */
+export function parseWsEndpointUrl(endpointUrl: string): ParsedWsEndpoint {
+    const m = /^(opc\.ws|opc\.wss|ws|wss):\/\/(.+)$/i.exec(endpointUrl);
+    if (!m) {
+        throw new Error(
+            `[node-opcua-client-browser] unsupported endpoint URL scheme for WebSocket transport: ${endpointUrl} ` +
+                `(expected one of opc.ws://, opc.wss://, ws://, wss://)`
+        );
+    }
+    const scheme = m[1].toLowerCase();
+    const secure = scheme === "opc.wss" || scheme === "wss";
+    const wsUrl = `${secure ? "wss" : "ws"}://${m[2]}`;
+    return { wsUrl, secure };
+}
+
+/**
+ * WebSocket-backed client transport. A sibling of `ClientTCP_transport`: both extend
+ * {@link ClientTransportBase} and reuse its UACP HEL/ACK machinery; the only
+ * difference is the socket flavour (`WebSocket` here, `net.Socket` in TCP).
+ */
+export class ClientWS_transport extends ClientTransportBase {
+    private readonly _webSocketCtor: WebSocketConstructor;
+    private readonly _strictSubprotocol: boolean;
+
+    constructor(options?: ClientWSTransportOptions) {
+        super(options);
+        const resolvedCtor =
+            options?.webSocketCtor ??
+            ((typeof globalThis !== "undefined" ? (globalThis as { WebSocket?: WebSocketConstructor }).WebSocket : undefined) as
+                | WebSocketConstructor
+                | undefined);
+        if (!resolvedCtor) {
+            throw new Error(
+                "[ClientWS_transport] no WebSocket constructor available: pass `webSocketCtor` explicitly or run in a browser / Node 22+"
+            );
+        }
+        this._webSocketCtor = resolvedCtor;
+        this._strictSubprotocol = !!options?.strictSubprotocol;
+    }
+
+    /**
+     * Opens a WebSocket to `endpointUrl`, adapts it to `ISocketLike`, and
+     * drives the inherited HEL/ACK transaction from `ClientTransportBase`.
+     */
+    public override connect(endpointUrl: string, callback: ErrorCallback): void {
+        this.endpointUrl = endpointUrl;
+
+        /* c8 ignore next */
+        doDebug && debugLog(`ClientWS_transport#connect(endpointUrl = ${endpointUrl})`);
+
+        let parsed: ParsedWsEndpoint;
+        try {
+            parsed = parseWsEndpointUrl(endpointUrl);
+        } catch (err) {
+            callback(err as Error);
+            return;
+        }
+
+        let ws: WebSocketLike;
+        try {
+            ws = new this._webSocketCtor(parsed.wsUrl, OPCUA_UACP_SUBPROTOCOL);
+        } catch (err) {
+            /* c8 ignore next */
+            doDebug && debugLog("WebSocket construction failed", (err as Error).message);
+            callback(err as Error);
+            return;
+        }
+
+        const socket: ISocketLike = new WsSocketAdapter(ws, parsed.wsUrl);
+
+        const onEarlyError = (err: Error) => {
+            callback(err);
+        };
+        socket.once("error", onEarlyError);
+
+        socket.once("connect", () => {
+            socket.removeListener("error", onEarlyError);
+
+            // Subprotocol negotiation check. Browser WS exposes `protocol` on the
+            // instance; `ws` package exposes it too. When the peer doesn't
+            // negotiate (e.g. a websockify bridge), `protocol` is an empty
+            // string. Only fail in strict mode.
+            const negotiated: string | undefined = (ws as unknown as { protocol?: string }).protocol;
+            if (negotiated && negotiated !== OPCUA_UACP_SUBPROTOCOL) {
+                const msg = `unexpected WebSocket subprotocol negotiated: "${negotiated}" (expected "${OPCUA_UACP_SUBPROTOCOL}")`;
+                if (this._strictSubprotocol) {
+                    callback(new Error(`[ClientWS_transport] ${msg}`));
+                    socket.destroy();
+                    return;
+                }
+                warningLog(msg);
+            } else if (!negotiated) {
+                /* c8 ignore next */
+                doDebug &&
+                    debugLog(
+                        `peer did not echo the "${OPCUA_UACP_SUBPROTOCOL}" subprotocol; continuing ` +
+                            `(set strictSubprotocol=true to reject this)`
+                    );
+            }
+
+            // Install the WebSocket-backed socket adapter into the inherited TCP_transport machinery.
+            assert(!this._socket, "transport should not have a socket yet");
+            this._install_socket(socket);
+
+            this._perform_HEL_ACK_transaction((err) => {
+                if (!err) {
+                    /* c8 ignore next */
+                    if (!this._socket) {
+                        return callback(new Error("Abandoned"));
+                    }
+                    this._install_post_connect_error_handler(endpointUrl);
+                    this.emit("connect");
+                } else {
+                    debugLog("_perform_HEL_ACK_transaction has failed with err=", err.message);
+                }
+                callback(err);
+            });
+        });
+    }
+    public override dispose(): void {
+        /* c8 ignore next */
+        doDebug && debugLog(" ClientWS_transport disposed");
+
+        super.dispose();
+    }
+}
+
+/**
+ * A factory that produces {@link ClientWS_transport} instances. Pass to
+ * `ClientSecureChannelLayerOptions.transportFactory` to route all channel
+ * traffic through a WebSocket.
+ *
+ * @example
+ *   const ws = browserWsTransportFactory.create({});
+ *   // or, on Node:
+ *   import WebSocket from "ws";
+ *   const factory: IClientTransportFactory = {
+ *       create(s) { return new ClientWS_transport({ ...s, webSocketCtor: WebSocket as any }); }
+ *   };
+ */
+export const browserWsTransportFactory: IClientTransportFactory = {
+    create(settings?: TransportSettingsOptions): IClientTransport {
+        return new ClientWS_transport(settings as ClientWSTransportOptions | undefined);
+    }
+};