doover-js 0.5.3 → 0.6.0

package/dist/test/react-client-status.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const react_1 = require("@testing-library/react");
+const react_2 = require("../react");
+function controllableClient() {
+    let status = { clientId: "x", connected: false, state: "disconnected", agentScope: "unknown", at: Date.now() };
+    const listeners = new Set();
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        client: {
+            agents: noop, channels: noop, messages: noop, aggregates: noop, alarms: noop, connections: noop, notifications: noop, permissions: noop, processors: noop, turn: noop, users: noop, rpc: noop,
+            gateway: { connect: async () => { }, disconnect: () => { }, reconnect: async () => { }, on: () => { }, off: () => { }, subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { }, sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => false, getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+            getCapabilities: () => new Set(), supports: () => false,
+            isConnected: () => status.connected, getStatus: () => status,
+            onStatusChange: (l) => { listeners.add(l); return () => listeners.delete(l); },
+            getAgentScope: async () => ({ mode: "all" }), getKnownAgentScope: () => "unknown",
+        },
+        push(s) { status = { ...status, ...s, at: Date.now() }; listeners.forEach((l) => l(status)); },
+    };
+}
+(0, mocha_1.describe)("useClientStatus", () => {
+    (0, mocha_1.it)("seeds with getStatus() and re-renders on onStatusChange", () => {
+        const { client, push } = controllableClient();
+        const { result } = (0, react_1.renderHook)(() => (0, react_2.useClientStatus)(), {
+            wrapper: ({ children }) => (0, jsx_runtime_1.jsx)(react_2.DooverProvider, { client: client, children: children }),
+        });
+        (0, chai_1.expect)(result.current.state).to.equal("disconnected");
+        (0, react_1.act)(() => push({ connected: true, state: "connected" }));
+        (0, chai_1.expect)(result.current.state).to.equal("connected");
+        (0, chai_1.expect)(result.current.connected).to.equal(true);
+    });
+});

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

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

package/dist/test/react-dataclient.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const react_1 = require("@testing-library/react");
+const react_2 = require("../react");
+const multiplex_client_1 = require("../client/multiplex-client");
+function stubMember(id) {
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: noop, channels: noop, messages: noop, aggregates: noop, alarms: noop, connections: noop, notifications: noop, permissions: noop, processors: noop, turn: noop, users: noop, rpc: noop,
+        gateway: { connect: async () => { }, disconnect: () => { }, reconnect: async () => { }, on: () => { }, off: () => { }, subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { }, sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => false, getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+        getCapabilities: () => new Set(["channels.list"]), supports: () => true,
+        isConnected: () => false, getStatus: () => ({ clientId: id, connected: false, state: "disconnected", agentScope: "unknown", at: Date.now() }),
+        onStatusChange: () => () => { }, getAgentScope: async () => ({ mode: "list", agentIds: [] }), getKnownAgentScope: () => "unknown",
+    };
+}
+(0, mocha_1.describe)("DooverProvider with a DataClient", () => {
+    (0, mocha_1.it)("accepts a MultiplexClient and useDooverClient returns it", () => {
+        const factory = (d) => stubMember(d.id);
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }], enable: ["cloud"] });
+        const { result } = (0, react_1.renderHook)(() => (0, react_2.useDooverClient)(), {
+            wrapper: ({ children }) => (0, jsx_runtime_1.jsx)(react_2.DooverProvider, { client: mux, children: children }),
+        });
+        (0, chai_1.expect)(result.current).to.equal(mux);
+    });
+});

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

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

package/dist/test/react-exports.test.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const r = __importStar(require("../react"));
+(0, mocha_1.describe)("react exports", () => {
+    (0, mocha_1.it)("exports useClientStatus and the key helpers", () => {
+        (0, chai_1.expect)(r.useClientStatus).to.be.a("function");
+        (0, chai_1.expect)(r.channelAggregateQueryKey).to.be.a("function");
+        (0, chai_1.expect)(r.useConnectionState).to.be.a("function"); // still exported (soft-deprecated)
+    });
+});

package/dist/test/react-sources-option.test.d.ts

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

package/dist/test/react-sources-option.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const react_1 = require("@testing-library/react");
+const react_query_1 = require("@tanstack/react-query");
+const react_2 = require("../react");
+const multiplex_client_1 = require("../client/multiplex-client");
+function aggMember(id, value) {
+    const src = { client: { id, kind: id.startsWith("local") ? "local" : "cloud" }, retrievedAt: 0, via: { transport: "rest", method: "aggregates.getAggregate", request: {}, startedAt: 0, durationMs: 0 } };
+    const noop = new Proxy({}, { get: () => () => Promise.resolve(undefined) });
+    return {
+        agents: noop,
+        channels: { getChannel: async () => ({ name: "c", owner_id: id, is_private: false }) },
+        messages: noop,
+        aggregates: { getAggregate: async () => ({ ...value, __source: src }) },
+        alarms: noop, connections: noop, notifications: noop, permissions: noop, processors: noop, turn: noop, users: noop, rpc: noop,
+        gateway: { connect: async () => { }, disconnect: () => { }, reconnect: async () => { }, on: () => { }, off: () => { }, subscribe: () => { }, unsubscribe: () => { }, subscribeToChannel: () => () => { }, syncChannel: () => { }, sendOneShotMessage: () => { }, getSession: () => null, isConnected: () => false, getSubscriptionCount: () => 0, getSubscriptions: () => [], setStats: () => { } },
+        getCapabilities: () => new Set(["aggregates.get", "channels.get", "gateway.subscribe"]),
+        supports: (c) => ["aggregates.get", "channels.get", "gateway.subscribe"].includes(c),
+        isConnected: () => false, getStatus: () => ({ clientId: id, connected: false, state: "disconnected", agentScope: { mode: "all" }, at: 0 }),
+        onStatusChange: () => () => { }, getAgentScope: async () => ({ mode: "all" }), getKnownAgentScope: () => ({ mode: "all" }),
+    };
+}
+(0, mocha_1.describe)("hooks: sources option + source-dimensioned keys", () => {
+    (0, mocha_1.it)("useChannelAggregate forwards sources and uses a source-dimensioned key; unscoped uses '*'", async () => {
+        const factory = (d) => d.id === "cloud"
+            ? aggMember("cloud", { data: { v: 1 }, attachments: [] })
+            : aggMember("local:7", { data: { v: 2 }, attachments: [] });
+        const mux = new multiplex_client_1.MultiplexClient({ factory, register: [{ id: "cloud", kind: "cloud" }, { id: "local:7", kind: "local" }], enableAll: true });
+        const queryClient = new react_query_1.QueryClient({ defaultOptions: { queries: { retry: false } } });
+        const wrapper = ({ children }) => ((0, jsx_runtime_1.jsx)(react_query_1.QueryClientProvider, { client: queryClient, children: (0, jsx_runtime_1.jsx)(react_2.DooverProvider, { client: mux, children: children }) }));
+        const scoped = (0, react_1.renderHook)(() => (0, react_2.useChannelAggregate)({ agentId: "dev7", channelName: "c" }, { sources: ["local:7"] }), { wrapper });
+        await (0, react_1.waitFor)(() => (0, chai_1.expect)(scoped.result.current.data).to.deep.equal({ v: 2 }));
+        // its cache entry lives under the source-dimensioned key:
+        (0, chai_1.expect)(queryClient.getQueryData((0, react_2.channelAggregateQueryKey)("dev7", "c", ["local:7"]))).to.exist;
+        // an unscoped hook for the same channel uses the "*" key — distinct entry:
+        (0, chai_1.expect)((0, react_2.channelAggregateQueryKey)("dev7", "c")).to.deep.equal(["doover", "agent", "dev7", "channel", "c", "src", "*"]);
+    });
+});

package/dist/test/react.test.js

@@ -95,7 +95,7 @@ function wrapper(client) {
         await (0, react_1.waitFor)(() => {
             (0, chai_1.expect)(result.current.isSuccess).to.equal(true);
         });
-        (0, chai_1.expect)(result.current.data).to.deep.equal([{ address: "x", agent_id: "a1" }]);
+        (0, chai_1.expect)(result.current.data?.[0]).to.deep.include({ address: "x", agent_id: "a1" });
         (0, chai_1.expect)(fetchMock.getCall(0).args[0]).to.equal("https://api.example.com/agents/a1/wss_connections");
     });
     (0, mocha_1.it)("useAgentConnections stays disabled when agentId is undefined", () => {
@@ -206,7 +206,7 @@ function wrapper(client) {
             await result.current.mutateAsync({ y: 2 });
         });
         const cached = queryClient.getQueryData((0, react_2.channelAggregateQueryKey)("a1", "ui_cmds"));
-        (0, chai_1.expect)(cached).to.deep.equal({ data: { y: 2 }, attachments: [] });
+        (0, chai_1.expect)(cached).to.deep.include({ data: { y: 2 }, attachments: [] });
     });
     (0, mocha_1.it)("useChannelMessages paginates and prepends on live messageCreate", async () => {
         const oldId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2025-12-31T23:59:00.000Z"));

package/dist/test/rpc-dispatcher.test.d.ts

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

package/dist/test/rpc-dispatcher.test.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const node_events_1 = require("node:events");
+const rpc_dispatcher_1 = require("../rpc/rpc-dispatcher");
+const errors_1 = require("../rpc/errors");
+const stats_1 = require("../client/stats");
+function makeFakeGateway() {
+    const ee = new node_events_1.EventEmitter();
+    let subscribeCalls = 0;
+    let unsubscribeCalls = 0;
+    const channels = new Map();
+    const key = (c) => `${c.agent_id}/${c.name}`;
+    const subscribeToChannel = (channel, handlers) => {
+        const k = key(channel);
+        let set = channels.get(k);
+        if (!set) {
+            set = new Set();
+            channels.set(k, set);
+            subscribeCalls += 1;
+        }
+        set.add(handlers);
+        ee.on("messageUpdate", (msg, requestData) => {
+            if (msg.channel.agent_id !== channel.agent_id || msg.channel.name !== channel.name)
+                return;
+            handlers.onMessageUpdate?.(msg, requestData);
+        });
+        let off = false;
+        return () => {
+            if (off)
+                return;
+            off = true;
+            set.delete(handlers);
+            if (set.size === 0) {
+                channels.delete(k);
+                unsubscribeCalls += 1;
+            }
+        };
+    };
+    return {
+        subscribeToChannel: subscribeToChannel,
+        emitMessageUpdate: (msg, rd) => ee.emit("messageUpdate", msg, rd),
+        get subscribeCalls() { return subscribeCalls; },
+        get unsubscribeCalls() { return unsubscribeCalls; },
+    };
+}
+function makeFakeMessagesApi() {
+    let nextId = "msg-1";
+    const posts = [];
+    const postMessage = (async (a, b, c) => {
+        const isPositional = typeof a === "string";
+        const agentId = isPositional ? a : a.agentId;
+        const channelName = isPositional ? b : a.channelName;
+        const body = isPositional ? c : b;
+        posts.push({ agentId, channelName, body });
+        const message = {
+            id: nextId,
+            data: body,
+            attachments: [],
+            author_id: "auth",
+            channel: { agent_id: agentId, name: channelName },
+            timestamp: 1,
+        };
+        return message;
+    });
+    return {
+        postMessage,
+        posts,
+        setNextId: (id) => { nextId = id; },
+    };
+}
+function rpcMessage(id, channel, status, request, response) {
+    return {
+        id,
+        data: { method: "do", request, status, response: response },
+        attachments: [],
+        author_id: "auth",
+        channel,
+        timestamp: 1,
+    };
+}
+describe("RpcDispatcher", () => {
+    it("send resolves on terminal success status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        messages.setNextId("rpc-1");
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const channel = { agent_id: "a1", name: "c1" };
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { x: 1 } });
+        // wait one microtask so postMessage settles and pending is registered
+        await new Promise((r) => setImmediate(r));
+        gw.emitMessageUpdate(rpcMessage("rpc-1", channel, { code: "success" }, { x: 1 }, { ok: true }));
+        const result = await promise;
+        (0, chai_1.expect)(result).to.deep.equal({ ok: true });
+        (0, chai_1.expect)(gw.subscribeCalls).to.equal(1);
+        (0, chai_1.expect)(gw.unsubscribeCalls).to.equal(1);
+    });
+});
+describe("RpcDispatcher additional outcomes", () => {
+    it("rejects with DooverRpcError on terminal error status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        messages.setNextId("rpc-2");
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const channel = { agent_id: "a1", name: "c1" };
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} });
+        await new Promise((r) => setImmediate(r));
+        gw.emitMessageUpdate(rpcMessage("rpc-2", channel, { code: "error", message: "nope" }, {}));
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught).to.be.instanceOf(errors_1.DooverRpcError);
+        (0, chai_1.expect)(caught.message).to.equal("nope");
+    });
+    it("rejects on timeoutMs with no terminal status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} }, { timeoutMs: 5 });
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught?.message).to.equal("RPC timed out");
+    });
+    it("rejects on AbortSignal.abort()", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const ac = new AbortController();
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} }, { signal: ac.signal });
+        await new Promise((r) => setImmediate(r));
+        ac.abort(new Error("user cancelled"));
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught?.message).to.equal("user cancelled");
+    });
+    it("two concurrent RPCs on the same channel share one gateway subscription", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        messages.setNextId("rpc-A");
+        const pA = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { n: 1 } });
+        await new Promise((r) => setImmediate(r));
+        messages.setNextId("rpc-B");
+        const pB = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { n: 2 } });
+        await new Promise((r) => setImmediate(r));
+        (0, chai_1.expect)(gw.subscribeCalls).to.equal(1);
+        const channel = { agent_id: "a1", name: "c1" };
+        gw.emitMessageUpdate(rpcMessage("rpc-A", channel, { code: "success" }, { n: 1 }, { a: true }));
+        gw.emitMessageUpdate(rpcMessage("rpc-B", channel, { code: "success" }, { n: 2 }, { b: true }));
+        (0, chai_1.expect)(await pA).to.deep.equal({ a: true });
+        (0, chai_1.expect)(await pB).to.deep.equal({ b: true });
+        (0, chai_1.expect)(gw.unsubscribeCalls).to.equal(1);
+    });
+});
+describe("RpcDispatcher stats integration", () => {
+    it("records start and end via collector when enabled", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const stats = new stats_1.DooverStatsCollector();
+        stats.setEnabled(true);
+        dispatcher.setStats(stats);
+        messages.setNextId("rpc-stats");
+        const channel = { agent_id: "a1", name: "c1" };
+        const p = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} });
+        await new Promise((r) => setImmediate(r));
+        (0, chai_1.expect)(stats.snapshot().rpc.pendingRpcs).to.equal(1);
+        gw.emitMessageUpdate(rpcMessage("rpc-stats", channel, { code: "success" }, {}, { ok: true }));
+        await p;
+        const snap = stats.snapshot();
+        (0, chai_1.expect)(snap.rpc.totalRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.completedRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.pendingRpcs).to.equal(0);
+        (0, chai_1.expect)(snap.rpc.peakPendingRpcs).to.equal(1);
+    });
+});

package/dist/test/stats-rpc.test.d.ts

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

package/dist/test/stats-rpc.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const stats_1 = require("../client/stats");
+describe("DooverStatsCollector RPC counters", () => {
+    it("returns zeroed rpc snapshot when disabled", () => {
+        const c = new stats_1.DooverStatsCollector();
+        const snap = c.snapshot();
+        (0, chai_1.expect)(snap.rpc).to.deep.equal({
+            enabled: false,
+            totalRpcs: 0,
+            pendingRpcs: 0,
+            completedRpcs: 0,
+            failedRpcs: 0,
+            timedOutRpcs: 0,
+            abortedRpcs: 0,
+            averageLatencyMs: null,
+            lastLatencyMs: null,
+            peakPendingRpcs: 0,
+        });
+    });
+    it("tracks success/error/timeout/abort separately", () => {
+        const c = new stats_1.DooverStatsCollector();
+        c.setEnabled(true);
+        const a = c.recordRpcStart();
+        const b = c.recordRpcStart();
+        const cc = c.recordRpcStart();
+        const d = c.recordRpcStart();
+        c.recordRpcEnd(a, "success");
+        c.recordRpcEnd(b, "error");
+        c.recordRpcEnd(cc, "timeout");
+        c.recordRpcEnd(d, "abort");
+        const snap = c.snapshot();
+        (0, chai_1.expect)(snap.rpc.totalRpcs).to.equal(4);
+        (0, chai_1.expect)(snap.rpc.pendingRpcs).to.equal(0);
+        (0, chai_1.expect)(snap.rpc.completedRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.failedRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.timedOutRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.abortedRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.averageLatencyMs).to.be.a("number");
+        (0, chai_1.expect)(snap.rpc.lastLatencyMs).to.be.a("number");
+    });
+    it("tracks peakPendingRpcs as a high-water mark", () => {
+        const c = new stats_1.DooverStatsCollector();
+        c.setEnabled(true);
+        const a = c.recordRpcStart();
+        const b = c.recordRpcStart();
+        const cc = c.recordRpcStart();
+        c.recordRpcEnd(a, "success");
+        c.recordRpcEnd(b, "success");
+        c.recordRpcEnd(cc, "success");
+        const d = c.recordRpcStart();
+        c.recordRpcEnd(d, "success");
+        (0, chai_1.expect)(c.snapshot().rpc.peakPendingRpcs).to.equal(3);
+    });
+    it("disabled collector short-circuits start (returns null)", () => {
+        const c = new stats_1.DooverStatsCollector();
+        (0, chai_1.expect)(c.recordRpcStart()).to.equal(null);
+    });
+    it("reset() clears RPC counters", () => {
+        const c = new stats_1.DooverStatsCollector();
+        c.setEnabled(true);
+        const a = c.recordRpcStart();
+        c.recordRpcEnd(a, "success");
+        c.reset();
+        (0, chai_1.expect)(c.snapshot().rpc.totalRpcs).to.equal(0);
+        (0, chai_1.expect)(c.snapshot().rpc.peakPendingRpcs).to.equal(0);
+    });
+});

package/dist/test/status-tracker.test.d.ts

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

package/dist/test/status-tracker.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const status_tracker_1 = require("../client/status-tracker");
+// Minimal GatewayClientLike stub: just on/off + isConnected + getSession.
+function makeGatewayStub() {
+    const listeners = new Map();
+    let connected = false;
+    let session = null;
+    return {
+        gw: {
+            on(e, h) {
+                (listeners.get(e) ?? listeners.set(e, new Set()).get(e)).add(h);
+            },
+            off(e, h) {
+                listeners.get(e)?.delete(h);
+            },
+            isConnected: () => connected,
+            getSession: () => session,
+        },
+        emit(e, ...args) {
+            listeners.get(e)?.forEach((h) => h(...args));
+        },
+        setConnected(v) { connected = v; },
+        setSession(s) { session = s; },
+    };
+}
+(0, mocha_1.describe)("ClientStatusTracker", () => {
+    (0, mocha_1.it)("derives state from gateway lifecycle and notifies listeners", () => {
+        const { gw, emit, setConnected, setSession } = makeGatewayStub();
+        const tracker = new status_tracker_1.ClientStatusTracker("cloud", gw, () => "all");
+        const seen = [];
+        const off = tracker.onChange((s) => seen.push(s.state));
+        (0, chai_1.expect)(tracker.getStatus().state).to.equal("disconnected");
+        (0, chai_1.expect)(tracker.getStatus().agentScope).to.equal("all");
+        emit("open");
+        (0, chai_1.expect)(tracker.getStatus().lastEvent).to.equal("open");
+        setConnected(true);
+        setSession({ session_id: "s1" });
+        emit("ready", { session_id: "s1" });
+        const ready = tracker.getStatus();
+        (0, chai_1.expect)(ready.connected).to.equal(true);
+        (0, chai_1.expect)(ready.state).to.equal("connected");
+        (0, chai_1.expect)(ready.session).to.deep.equal({ id: "s1" });
+        setConnected(false);
+        emit("close", { code: 1006 });
+        (0, chai_1.expect)(tracker.getStatus().connected).to.equal(false);
+        (0, chai_1.expect)(tracker.getStatus().state).to.equal("connecting");
+        emit("wssError", { message: "boom" });
+        (0, chai_1.expect)(tracker.getStatus().state).to.equal("error");
+        (0, chai_1.expect)(tracker.getStatus().lastError).to.equal("boom");
+        (0, chai_1.expect)(seen.length).to.be.greaterThan(3);
+        off();
+        emit("open");
+        const len = seen.length;
+        emit("ready", { session_id: "s2" });
+        (0, chai_1.expect)(seen.length).to.equal(len); // unsubscribed
+    });
+    (0, mocha_1.it)("recovers from error state after reconnect", () => {
+        const { gw, emit, setConnected, setSession } = makeGatewayStub();
+        const tracker = new status_tracker_1.ClientStatusTracker("cloud", gw, () => "all");
+        // Drive to error state first
+        emit("open");
+        setConnected(true);
+        setSession({ session_id: "s1" });
+        emit("ready", { session_id: "s1" });
+        setConnected(false);
+        emit("close", { code: 1006 });
+        emit("wssError", { message: "connection lost" });
+        (0, chai_1.expect)(tracker.getStatus().state).to.equal("error");
+        (0, chai_1.expect)(tracker.getStatus().lastError).to.equal("connection lost");
+        // Reconnect: open clears error, transitions to connecting
+        emit("open");
+        (0, chai_1.expect)(tracker.getStatus().state).to.equal("connecting");
+        (0, chai_1.expect)(tracker.getStatus().lastError).to.be.undefined;
+        // Session established: transitions to connected with new session
+        setConnected(true);
+        setSession({ session_id: "s2" });
+        emit("ready", { session_id: "s2" });
+        const status = tracker.getStatus();
+        (0, chai_1.expect)(status.state).to.equal("connected");
+        (0, chai_1.expect)(status.session).to.deep.equal({ id: "s2" });
+    });
+});

package/dist/test/users-api.test.d.ts

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

package/dist/test/users-api.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const users_api_1 = require("../apis/users-api");
+const api_overloads_test_1 = require("./api-overloads.test");
+describe("UsersApi", () => {
+    it("getMe calls /users/me on controlApiUrl", async () => {
+        const rest = (0, api_overloads_test_1.makeRestStub)();
+        const api = new users_api_1.UsersApi(rest, "https://control.example.com");
+        await api.getMe();
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        (0, chai_1.expect)(rest.calls[0].method).to.equal("get");
+        (0, chai_1.expect)(rest.calls[0].args).to.deep.equal([
+            "/users/me",
+            undefined,
+            "https://control.example.com",
+        ]);
+    });
+});