doover-js 0.1.2 → 0.2.0

package/dist/test/doover-client.test.js

@@ -26,4 +26,17 @@ const helpers_1 = require("./helpers");
         (0, chai_1.expect)(client.agents).to.exist;
         (0, chai_1.expect)(client.gateway).to.exist;
     });
+    (0, mocha_1.it)("shares a single GatewayClient between client.gateway and client.viewer.gateway", () => {
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(),
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        // Regression: these used to be separate GatewayClient instances,
+        // each opening its own WebSocket on connect().
+        (0, chai_1.expect)(client.gateway).to.equal(client.viewer.gateway);
+    });
 });

package/dist/test/doover-data-provider.test.js

@@ -104,6 +104,23 @@ const helpers_1 = require("./helpers");
         (0, chai_1.expect)(messages?.map((message) => message.id)).to.deep.equal([oldId, newId]);
         (0, chai_1.expect)(fetchMock.getCall(0).args[0]).to.equal("https://api.example.com/agents/a1/channels/c1/messages?before=cursor&limit=10");
     });
+    (0, mocha_1.it)("forwards listMessages options (limit, after, field_name)", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)([]));
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await provider.getMessages({ agentId: "a1", channelName: "c1" }, { before: "b1", after: "a1", limit: 50, field_name: ["x", "y"] });
+        const url = fetchMock.getCall(0).args[0];
+        (0, chai_1.expect)(url).to.include("before=b1");
+        (0, chai_1.expect)(url).to.include("after=a1");
+        (0, chai_1.expect)(url).to.include("limit=50");
+        (0, chai_1.expect)(url).to.include("field_name=x");
+        (0, chai_1.expect)(url).to.include("field_name=y");
+    });
     (0, mocha_1.it)("prefers channel aggregate data and falls back to the aggregate endpoint", async () => {
         const fetchMock = (0, helpers_1.createFetchMock)((url) => {
             if (url.endsWith("/channels/c1")) {
@@ -227,4 +244,142 @@ const helpers_1 = require("./helpers");
             aggregatePath: "path/to/value",
         });
     });
+    (0, mocha_1.it)("sendRPC posts an rpc message, correlates the response by id, and resolves on success", async () => {
+        const rpcId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/messages")) {
+                return (0, helpers_1.createJsonResponse)({
+                    id: rpcId,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: {
+                        type: "rpc",
+                        method: "ping",
+                        request: {},
+                        status: { code: "sent" },
+                        response: {},
+                    },
+                    attachments: [],
+                });
+            }
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const statuses = [];
+        const promise = provider.sendRPC({ agentId: "a1", channelName: "c1" }, { method: "ping", request: {} }, { onStatus: (status) => statuses.push(status.code) });
+        // Let subscribe + POST resolve.
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "t1", subscriptions: [] },
+        });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        // Progress updates.
+        ws.receive({
+            op: 0,
+            t: "MessageUpdate",
+            d: {
+                id: rpcId,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {
+                    type: "rpc",
+                    method: "ping",
+                    request: {},
+                    status: { code: "acknowledged", message: { timestamp: 1 } },
+                    response: {},
+                },
+                attachments: [],
+                request_data: {},
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "MessageUpdate",
+            d: {
+                id: rpcId,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {
+                    type: "rpc",
+                    method: "ping",
+                    request: {},
+                    status: { code: "success" },
+                    response: { pong: true },
+                },
+                attachments: [],
+                request_data: {},
+            },
+        });
+        await (0, chai_1.expect)(promise).to.eventually.deep.equal({ pong: true });
+        (0, chai_1.expect)(statuses).to.deep.equal(["acknowledged", "success"]);
+    });
+    (0, mocha_1.it)("sendRPC rejects with the status message on error", async () => {
+        const rpcId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/messages")) {
+                return (0, helpers_1.createJsonResponse)({
+                    id: rpcId,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: {
+                        type: "rpc",
+                        method: "ping",
+                        request: {},
+                        status: { code: "sent" },
+                        response: {},
+                    },
+                    attachments: [],
+                });
+            }
+            return (0, helpers_1.createJsonResponse)({});
+        });
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const promise = provider.sendRPC({ agentId: "a1", channelName: "c1" }, { method: "ping", request: {} });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "t1", subscriptions: [] },
+        });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        ws.receive({
+            op: 0,
+            t: "MessageUpdate",
+            d: {
+                id: rpcId,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {
+                    type: "rpc",
+                    method: "ping",
+                    request: {},
+                    status: { code: "error", message: "boom" },
+                    response: {},
+                },
+                attachments: [],
+                request_data: {},
+            },
+        });
+        await (0, chai_1.expect)(promise).to.eventually.be.rejectedWith("boom");
+    });
 });

package/dist/test/gateway-client.test.js

@@ -203,16 +203,14 @@ const helpers_1 = require("./helpers");
         (0, chai_1.expect)(unsubscribed.calledOnce).to.equal(true);
         (0, chai_1.expect)(wssError.calledWith({ message: "boom" })).to.equal(true);
     });
-    (0, mocha_1.it)("sends heartbeats, measures latency, and handles session cancellation", () => {
+    (0, mocha_1.it)("handles session cancellation (op 3)", () => {
         const client = new gateway_client_1.GatewayClient({
             dataRestUrl: "https://api.example.com",
             controlApiUrl: "https://control.example.com",
             dataWssUrl: "wss://ws.example.com",
             webSocketImpl: helpers_1.MockWebSocket,
         });
-        const ack = sinon_1.default.spy();
         const cancelled = sinon_1.default.spy();
-        client.on("heartbeatAck", ack);
         client.on("sessionCancelled", cancelled);
         client.connect();
         const ws = helpers_1.MockWebSocket.instances[0];
@@ -223,13 +221,129 @@ const helpers_1 = require("./helpers");
             t: "Ready",
             d: { session_id: "s1", session_token: "token", subscriptions: [] },
         });
-        sinon_1.default.clock.tick(20000);
-        (0, chai_1.expect)(JSON.parse(ws.sent[ws.sent.length - 1])).to.deep.equal({ op: 1, d: {} });
-        sinon_1.default.clock.tick(10);
-        ws.receive({ op: 2, d: {} });
-        (0, chai_1.expect)(ack.calledWith(10)).to.equal(true);
         ws.receive({ op: 3, d: {} });
         (0, chai_1.expect)(cancelled.calledOnce).to.equal(true);
         (0, chai_1.expect)(client.getSession()).to.equal(null);
     });
+    (0, mocha_1.it)("reconnects with exponential backoff + jitter on unexpected close", () => {
+        // Make jitter deterministic: Math.random() → 1 means "wait the full backoff window".
+        const randomStub = sinon_1.default.stub(Math, "random").returns(1);
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        client.connect();
+        helpers_1.MockWebSocket.instances[0].open();
+        helpers_1.MockWebSocket.instances[0].close(1006, "transport closed");
+        // 1st attempt: ~1s window
+        sinon_1.default.clock.tick(999);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(1);
+        sinon_1.default.clock.tick(1);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(2);
+        helpers_1.MockWebSocket.instances[1].open();
+        helpers_1.MockWebSocket.instances[1].close(1006, "transport closed");
+        // 2nd attempt: ~2s window
+        sinon_1.default.clock.tick(1999);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(2);
+        sinon_1.default.clock.tick(1);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(3);
+        // Successful Ready should reset the attempt counter.
+        helpers_1.MockWebSocket.instances[2].open();
+        helpers_1.MockWebSocket.instances[2].receive({ op: 0, t: "Hello", d: {} });
+        helpers_1.MockWebSocket.instances[2].receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "token", subscriptions: [] },
+        });
+        helpers_1.MockWebSocket.instances[2].close(1006, "transport closed");
+        sinon_1.default.clock.tick(999);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(3);
+        sinon_1.default.clock.tick(1);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(4);
+        randomStub.restore();
+    });
+    (0, mocha_1.it)("reconnects immediately on visibilitychange → visible", () => {
+        const listeners = new Map();
+        const fakeDocument = {
+            visibilityState: "hidden",
+            addEventListener: (event, handler) => {
+                listeners.set(event, handler);
+            },
+            removeEventListener: (event) => {
+                listeners.delete(event);
+            },
+        };
+        Object.defineProperty(globalThis, "document", {
+            value: fakeDocument,
+            configurable: true,
+            writable: true,
+        });
+        sinon_1.default.stub(Math, "random").returns(1);
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        client.connect();
+        helpers_1.MockWebSocket.instances[0].open();
+        helpers_1.MockWebSocket.instances[0].close(1006, "transport closed");
+        // Pending backoff would wait up to 1s.
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(1);
+        // Tab returns to visible — bypass backoff, reconnect now.
+        fakeDocument.visibilityState = "visible";
+        listeners.get("visibilitychange")?.(new Event("visibilitychange"));
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(2);
+        // @ts-expect-error — cleanup test global
+        delete globalThis.document;
+    });
+    (0, mocha_1.it)("skips lifecycle listeners when disableBrowserLifecycleHooks is true", () => {
+        const addSpy = sinon_1.default.spy();
+        const fakeDocument = {
+            visibilityState: "visible",
+            addEventListener: addSpy,
+            removeEventListener: sinon_1.default.spy(),
+        };
+        Object.defineProperty(globalThis, "document", {
+            value: fakeDocument,
+            configurable: true,
+            writable: true,
+        });
+        new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        (0, chai_1.expect)(addSpy.called).to.equal(false);
+        // @ts-expect-error — cleanup test global
+        delete globalThis.document;
+    });
+    (0, mocha_1.it)("caps backoff at 30s and does not reconnect after explicit disconnect", () => {
+        const randomStub = sinon_1.default.stub(Math, "random").returns(1);
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        client.connect();
+        // Force many failed attempts to push backoff past the cap.
+        for (let i = 0; i < 10; i += 1) {
+            const ws = helpers_1.MockWebSocket.instances[i];
+            ws.open();
+            ws.close(1006, "transport closed");
+            sinon_1.default.clock.tick(30000);
+        }
+        // After 10 attempts we should have 11 sockets, and the delay never exceeds 30s.
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(11);
+        // Explicit disconnect must not schedule a further reconnect.
+        client.disconnect();
+        sinon_1.default.clock.tick(60000);
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances.length).to.equal(11);
+        randomStub.restore();
+    });
 });

package/dist/test/react.test.d.ts

@@ -0,0 +1 @@
+export {};