@neta-art/cohub 1.0.0

package/dist/websocket.js

@@ -0,0 +1,398 @@
+import { realtimeEnvelopeSchema, } from "@neta-art/cohub-protocol/realtime";
+const createEventMap = () => ({
+    open: new Set(),
+    close: new Set(),
+    error: new Set(),
+    event: new Set(),
+    ready: new Set(),
+    auth: new Set(),
+    messageAccepted: new Set(),
+    serverError: new Set(),
+    pong: new Set(),
+});
+const toWebSocketUrl = (input) => {
+    const base = (input?.trim() || "").replace(/\/$/, "");
+    if (base) {
+        if (base.startsWith("ws://") || base.startsWith("wss://"))
+            return `${base}/ws`;
+        if (base.startsWith("http://"))
+            return `${base.replace(/^http:/, "ws:")}/ws`;
+        if (base.startsWith("https://"))
+            return `${base.replace(/^https:/, "wss:")}/ws`;
+    }
+    if (typeof window !== "undefined") {
+        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        return `${protocol}//${window.location.host}/ws`;
+    }
+    return "ws://localhost:8788/ws";
+};
+const normalizeOptions = (options = {}) => ({
+    url: toWebSocketUrl(options.url),
+    autoReconnect: options.autoReconnect !== false,
+    reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1000,
+    reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15000,
+    pingIntervalMs: options.pingIntervalMs ?? 20000,
+    pongTimeoutMs: options.pongTimeoutMs ?? 15000,
+    debug: options.debug === true,
+});
+class WebsocketAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WebsocketAuthError";
+    }
+}
+export class WebsocketClient {
+    url;
+    autoReconnect;
+    reconnectBaseDelayMs;
+    reconnectMaxDelayMs;
+    pingIntervalMs;
+    pongTimeoutMs;
+    debug;
+    getAccessToken;
+    WebSocketImpl;
+    ws = null;
+    pingTimer = null;
+    reconnectTimer = null;
+    reconnectAttempt = 0;
+    manuallyClosed = false;
+    connectPromise = null;
+    authWaiter = null;
+    awaitingPong = false;
+    lastPingRequestId = null;
+    pongDeadlineAt = 0;
+    state = "idle";
+    connectionId = null;
+    listeners = createEventMap();
+    constructor(options = {}) {
+        const normalized = normalizeOptions(options);
+        this.url = normalized.url;
+        this.autoReconnect = normalized.autoReconnect;
+        this.reconnectBaseDelayMs = normalized.reconnectBaseDelayMs;
+        this.reconnectMaxDelayMs = normalized.reconnectMaxDelayMs;
+        this.pingIntervalMs = normalized.pingIntervalMs;
+        this.pongTimeoutMs = normalized.pongTimeoutMs;
+        this.debug = normalized.debug;
+        this.getAccessToken = options.getAccessToken;
+        this.WebSocketImpl = options.WebSocketImpl ?? WebSocket;
+    }
+    on(type, handler) {
+        this.listeners[type].add(handler);
+        return () => this.off(type, handler);
+    }
+    off(type, handler) {
+        this.listeners[type].delete(handler);
+    }
+    emit(type, payload) {
+        for (const handler of this.listeners[type]) {
+            handler(payload);
+        }
+    }
+    log(...args) {
+        if (this.debug)
+            console.log("[WebsocketClient]", ...args);
+    }
+    async connect() {
+        if (this.connectPromise)
+            return this.connectPromise;
+        if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN)
+            return;
+        this.manuallyClosed = false;
+        this.state = "connecting";
+        this.connectPromise = new Promise((resolve, reject) => {
+            const ws = new this.WebSocketImpl(this.url);
+            this.ws = ws;
+            let settled = false;
+            const rejectOnce = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.connectPromise = null;
+                reject(error);
+            };
+            const resolveOnce = () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.connectPromise = null;
+                resolve();
+            };
+            ws.onopen = async () => {
+                try {
+                    this.log("connected", this.url);
+                    this.startPingLoop();
+                    await this.authenticate();
+                    this.state = "open";
+                    this.reconnectAttempt = 0;
+                    this.emit("open", { connectionId: this.connectionId });
+                    resolveOnce();
+                }
+                catch (error) {
+                    const authError = error instanceof Error ? error : new Error("authentication failed");
+                    rejectOnce(authError);
+                    ws.close(4003, authError.message);
+                }
+            };
+            ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+            ws.onerror = (error) => {
+                this.emit("error", { error });
+            };
+            ws.onclose = (event) => {
+                this.stopPingLoop();
+                const wasConnecting = this.state === "connecting";
+                this.state = "closed";
+                this.ws = null;
+                this.rejectAuthWaiter(new Error(`WebSocket closed: ${event.code} ${event.reason || ""}`.trim()));
+                const willReconnect = !this.manuallyClosed && this.autoReconnect;
+                this.emit("close", {
+                    code: event.code,
+                    reason: event.reason,
+                    willReconnect,
+                });
+                if (wasConnecting) {
+                    rejectOnce(new Error(`WebSocket closed: ${event.code} ${event.reason || ""}`.trim()));
+                    if (event.code === 4001 && willReconnect) {
+                        void this.scheduleReconnect();
+                    }
+                    return;
+                }
+                if (willReconnect) {
+                    void this.scheduleReconnect();
+                }
+            };
+        });
+        return this.connectPromise;
+    }
+    async disconnect(code = 1000, reason = "manual") {
+        this.manuallyClosed = true;
+        this.clearReconnectTimer();
+        this.stopPingLoop();
+        this.state = "closed";
+        this.rejectAuthWaiter(new Error("disconnected"));
+        this.ws?.close(code, reason);
+        this.ws = null;
+        this.connectPromise = null;
+    }
+    async sendMessage(input) {
+        await this.ensureOpen();
+        this.send({
+            type: "session.message.create",
+            requestId: input.requestId,
+            payload: {
+                spaceId: input.spaceId,
+                sessionId: input.sessionId,
+                content: input.content,
+                clientMessageId: input.clientMessageId,
+                model: input.model,
+                provider: input.provider,
+            },
+        });
+    }
+    ack(eventId, requestId) {
+        this.send({
+            type: "ack",
+            requestId,
+            payload: eventId ? { eventId } : undefined,
+        });
+    }
+    ping(requestId) {
+        const effectiveRequestId = requestId ?? `ping-${Date.now()}`;
+        this.awaitingPong = true;
+        this.lastPingRequestId = effectiveRequestId;
+        this.pongDeadlineAt = Date.now() + this.pongTimeoutMs;
+        this.send({ type: "ping", requestId: effectiveRequestId, payload: {} });
+    }
+    async ensureOpen() {
+        if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN)
+            return;
+        await this.connect();
+    }
+    send(event) {
+        const ws = this.ws;
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            throw new Error("websocket is not open");
+        }
+        ws.send(JSON.stringify(event));
+    }
+    async authenticate() {
+        const token = this.getAccessToken ? await this.getAccessToken() : null;
+        if (!token)
+            throw new WebsocketAuthError("missing access token");
+        const waiter = this.createAuthWaiter();
+        this.send({ type: "auth", payload: { token } });
+        await waiter.promise;
+    }
+    createAuthWaiter() {
+        this.rejectAuthWaiter(new Error("superseded auth waiter"));
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.authWaiter = { promise, resolve, reject };
+        return this.authWaiter;
+    }
+    resolveAuthWaiter() {
+        if (!this.authWaiter)
+            return;
+        this.authWaiter.resolve();
+        this.authWaiter = null;
+    }
+    rejectAuthWaiter(error) {
+        if (!this.authWaiter)
+            return;
+        this.authWaiter.reject(error);
+        this.authWaiter = null;
+    }
+    handleMessage(raw) {
+        let parsed;
+        try {
+            parsed = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(String(raw));
+        }
+        catch {
+            this.emit("error", { error: new Error("invalid websocket payload") });
+            return;
+        }
+        const result = realtimeEnvelopeSchema.safeParse(parsed);
+        if (!result.success) {
+            this.emit("error", { error: new Error("invalid realtime envelope") });
+            return;
+        }
+        const envelope = result.data;
+        switch (envelope.type) {
+            case "system.ready": {
+                const connectionId = typeof envelope.payload.connectionId === "string"
+                    ? envelope.payload.connectionId
+                    : null;
+                if (connectionId) {
+                    this.connectionId = connectionId;
+                    this.emit("ready", { connectionId });
+                }
+                this.emit("event", envelope);
+                return;
+            }
+            case "system.auth.ok": {
+                const connectionId = typeof envelope.payload.connectionId === "string"
+                    ? envelope.payload.connectionId
+                    : this.connectionId;
+                const user = envelope.payload.user && typeof envelope.payload.user === "object"
+                    ? envelope.payload.user
+                    : {};
+                if (connectionId) {
+                    this.connectionId = connectionId;
+                    this.emit("auth", { connectionId, user });
+                }
+                this.resolveAuthWaiter();
+                this.emit("event", envelope);
+                return;
+            }
+            case "system.request.error": {
+                const message = typeof envelope.payload.message === "string"
+                    ? envelope.payload.message
+                    : "request failed";
+                const code = typeof envelope.payload.code === "string"
+                    ? envelope.payload.code
+                    : undefined;
+                const error = new WebsocketAuthError(message);
+                this.rejectAuthWaiter(error);
+                this.emit("serverError", {
+                    code,
+                    message,
+                    requestId: envelope.requestId ?? null,
+                    sessionId: envelope.sessionId ?? null,
+                    spaceId: envelope.spaceId ?? null,
+                });
+                this.emit("event", envelope);
+                return;
+            }
+            case "session.request.accepted": {
+                const payload = envelope.payload;
+                this.emit("messageAccepted", {
+                    requestId: envelope.requestId ?? null,
+                    sessionId: envelope.sessionId ?? null,
+                    spaceId: envelope.spaceId ?? null,
+                    clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null,
+                });
+                this.emit("event", envelope);
+                return;
+            }
+            case "session.request.error": {
+                const payload = envelope.payload;
+                this.emit("serverError", {
+                    code: typeof payload.code === "string" ? payload.code : undefined,
+                    message: typeof payload.message === "string" ? payload.message : undefined,
+                    requestId: envelope.requestId ?? null,
+                    sessionId: envelope.sessionId ?? null,
+                    spaceId: envelope.spaceId ?? null,
+                    clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null,
+                });
+                this.emit("event", envelope);
+                return;
+            }
+            case "system.pong": {
+                const requestId = envelope.requestId ?? null;
+                if (!requestId || requestId === this.lastPingRequestId) {
+                    this.awaitingPong = false;
+                    this.lastPingRequestId = null;
+                    this.pongDeadlineAt = 0;
+                }
+                this.emit("pong", { requestId });
+                return;
+            }
+            case "system.ack.ok": {
+                return;
+            }
+            default: {
+                this.emit("event", envelope);
+                return;
+            }
+        }
+    }
+    startPingLoop() {
+        this.stopPingLoop();
+        this.pingTimer = setInterval(() => {
+            if (this.ws?.readyState !== WebSocket.OPEN)
+                return;
+            if (this.awaitingPong &&
+                this.pongDeadlineAt > 0 &&
+                Date.now() > this.pongDeadlineAt) {
+                this.emit("error", { error: new Error("websocket pong timeout") });
+                this.ws.close(4002, "pong timeout");
+                return;
+            }
+            this.ping();
+        }, this.pingIntervalMs);
+    }
+    stopPingLoop() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        this.awaitingPong = false;
+        this.lastPingRequestId = null;
+        this.pongDeadlineAt = 0;
+    }
+    clearReconnectTimer() {
+        if (!this.reconnectTimer)
+            return;
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+    }
+    async scheduleReconnect() {
+        this.clearReconnectTimer();
+        const delay = Math.min(this.reconnectBaseDelayMs * 2 ** this.reconnectAttempt, this.reconnectMaxDelayMs);
+        this.reconnectAttempt += 1;
+        await new Promise((resolve) => {
+            this.reconnectTimer = setTimeout(() => resolve(), delay);
+        });
+        if (this.manuallyClosed)
+            return;
+        await this.connect().catch((error) => {
+            this.emit("error", { error });
+        });
+    }
+}
+export const createWebsocketClient = (options) => new WebsocketClient(options);

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@neta-art/cohub",
+  "version": "1.0.0",
+  "description": "Cohub SDK for spaces, sessions, checkpoints, and realtime agent collaboration.",
+  "license": "UNLICENSED",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/neta-art/cohub.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://github.com/neta-art/cohub",
+  "keywords": [
+    "cohub",
+    "sdk",
+    "ai",
+    "agent",
+    "spaces",
+    "realtime",
+    "websocket"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "import": "./dist/http.js"
+    },
+    "./websocket": {
+      "types": "./dist/websocket.d.ts",
+      "import": "./dist/websocket.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@neta-art/cohub-protocol": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}