wrc-ts 0.1.0

package/dist/ws-transport.d.ts

@@ -0,0 +1,15 @@
+import type { Transport, UnaryResponse, StreamResponse, ContextValues } from "@connectrpc/connect";
+import type { DescMessage, DescMethodUnary, DescMethodStreaming, MessageInitShape } from "@bufbuild/protobuf";
+export declare class WebSocketTransport implements Transport {
+    private ws;
+    private pending;
+    private queue;
+    private connected;
+    private url;
+    constructor(url: string);
+    private connect;
+    private send;
+    unary<I extends DescMessage, O extends DescMessage>(method: DescMethodUnary<I, O>, signal: AbortSignal | undefined, _timeoutMs: number | undefined, _header: HeadersInit | undefined, input: MessageInitShape<I>, _contextValues?: ContextValues): Promise<UnaryResponse<I, O>>;
+    stream<I extends DescMessage, O extends DescMessage>(_method: DescMethodStreaming<I, O>, _signal: AbortSignal | undefined, _timeoutMs: number | undefined, _header: HeadersInit | undefined, _input: AsyncIterable<MessageInitShape<I>>, _contextValues?: ContextValues): Promise<StreamResponse<I, O>>;
+    close(): void;
+}

package/dist/ws-transport.js

@@ -0,0 +1,99 @@
+import { create, toBinary, fromBinary } from "@bufbuild/protobuf";
+let nextId = 0;
+export class WebSocketTransport {
+    constructor(url) {
+        this.ws = null;
+        this.pending = new Map();
+        this.queue = [];
+        this.connected = false;
+        this.url = url;
+        this.connect();
+    }
+    connect() {
+        this.ws = new WebSocket(this.url);
+        this.ws.binaryType = "arraybuffer";
+        this.ws.onopen = () => {
+            this.connected = true;
+            for (const msg of this.queue) {
+                this.ws.send(msg);
+            }
+            this.queue = [];
+        };
+        this.ws.onmessage = (ev) => {
+            const buf = new Uint8Array(ev.data);
+            if (buf.length < 5)
+                return;
+            const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+            const id = view.getUint32(0, true);
+            const status = buf[4];
+            const payload = buf.slice(5);
+            const call = this.pending.get(id);
+            if (!call)
+                return;
+            this.pending.delete(id);
+            if (status === 0) {
+                call.resolve(payload);
+            }
+            else {
+                call.reject(new Error(new TextDecoder().decode(payload)));
+            }
+        };
+        this.ws.onclose = () => {
+            this.connected = false;
+            for (const [, call] of this.pending) {
+                call.reject(new Error("WebSocket closed"));
+            }
+            this.pending.clear();
+            setTimeout(() => this.connect(), 1000);
+        };
+        this.ws.onerror = () => {
+            this.ws?.close();
+        };
+    }
+    send(data) {
+        if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(data);
+        }
+        else {
+            this.queue.push(data);
+        }
+    }
+    async unary(method, signal, _timeoutMs, _header, input, _contextValues) {
+        const id = ++nextId;
+        const methodName = `${method.parent.typeName}/${method.name}`;
+        const inputMsg = create(method.input, input);
+        const payload = toBinary(method.input, inputMsg);
+        const methodBytes = new TextEncoder().encode(methodName);
+        const frame = new Uint8Array(6 + methodBytes.length + payload.length);
+        const view = new DataView(frame.buffer);
+        view.setUint32(0, id, true);
+        view.setUint16(4, methodBytes.length, true);
+        frame.set(methodBytes, 6);
+        frame.set(payload, 6 + methodBytes.length);
+        const responsePayload = await new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.send(frame);
+            if (signal) {
+                signal.addEventListener("abort", () => {
+                    this.pending.delete(id);
+                    reject(signal.reason ?? new Error("aborted"));
+                }, { once: true });
+            }
+        });
+        const output = fromBinary(method.output, responsePayload);
+        return {
+            stream: false,
+            service: method.parent,
+            method,
+            header: new Headers(),
+            trailer: new Headers(),
+            message: output,
+        };
+    }
+    async stream(_method, _signal, _timeoutMs, _header, _input, _contextValues) {
+        throw new Error("Streaming not supported over WebSocket transport");
+    }
+    close() {
+        this.ws?.close();
+    }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "wrc-ts",
+  "version": "0.1.0",
+  "description": "Official SDK for WebRobot Cloud — undetected stealth browsers in the cloud. Rent real Chromium sessions with unique fingerprints, built-in proxies, captcha solving, human-like input and live video — scale web scraping and automation without running a single browser yourself.",
+  "main": "dist/index.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/wrc.browser.js",
+      "default": "./dist/wrc.browser.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build:proto": "npx buf generate",
+    "build:node": "tsc -p tsconfig.json",
+    "build:browser": "npx esbuild src/browser.ts --bundle --format=esm --outfile=dist/wrc.browser.js",
+    "build": "npm run build:proto && npm run build:node && npm run build:browser",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "puppeteer",
+    "playwright",
+    "stealth",
+    "undetected",
+    "undetected-browser",
+    "anti-detect",
+    "bot-detection",
+    "fingerprint",
+    "cloudflare",
+    "cloudflare-bypass",
+    "perimeterx",
+    "perimeterx-bypass",
+    "datadome",
+    "datadome-bypass",
+    "captcha",
+    "headless",
+    "chrome",
+    "chromium",
+    "cloud-browser",
+    "browser-use"
+  ],
+  "author": "webrobot-dev",
+  "license": "MIT",
+  "homepage": "https://webrobot.cloud/docs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webrobot-dev/wrc-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/webrobot-dev/wrc-ts/issues"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.11.0",
+    "@connectrpc/connect": "^2.1.1",
+    "@connectrpc/connect-node": "^2.1.1"
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.66.1",
+    "@bufbuild/protoc-gen-es": "^2.11.0",
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.27.4",
+    "typescript": "^5.9.3"
+  }
+}