@antelopejs/dms-ai 0.1.4 → 0.1.5

package/frontend-vue/tests/backoff.test.ts

@@ -1,44 +1,40 @@
-import { describe, expect, it } from 'vitest'
-import {
-	createBackoff,
-	nextDelay,
-	resetBackoff,
-} from '../app/runtime/backoff'
-import { CHANNEL_RECONNECT_DELAYS_MS } from '../app/runtime/constants'
+import { describe, expect, it } from "vitest";
+import { createBackoff, nextDelay, resetBackoff } from "../app/runtime/backoff";
+import { CHANNEL_RECONNECT_DELAYS_MS } from "../app/runtime/constants";
 
-describe('backoff helper', () => {
-	it('returns each schedule entry in order then caps at the last value', () => {
-		const state = createBackoff()
-		const observed: number[] = []
+describe("backoff helper", () => {
+	it("returns each schedule entry in order then caps at the last value", () => {
+		const state = createBackoff();
+		const observed: number[] = [];
 		for (let i = 0; i < CHANNEL_RECONNECT_DELAYS_MS.length + 3; i += 1) {
-			observed.push(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS))
+			observed.push(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS));
 		}
 		const expected = [
 			...CHANNEL_RECONNECT_DELAYS_MS,
 			CHANNEL_RECONNECT_DELAYS_MS[CHANNEL_RECONNECT_DELAYS_MS.length - 1],
 			CHANNEL_RECONNECT_DELAYS_MS[CHANNEL_RECONNECT_DELAYS_MS.length - 1],
 			CHANNEL_RECONNECT_DELAYS_MS[CHANNEL_RECONNECT_DELAYS_MS.length - 1],
-		]
-		expect(observed).toEqual(expected)
-	})
+		];
+		expect(observed).toEqual(expected);
+	});
 
-	it('resetBackoff returns the schedule to schedule[0]', () => {
-		const state = createBackoff()
-		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
-		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
-		resetBackoff(state)
+	it("resetBackoff returns the schedule to schedule[0]", () => {
+		const state = createBackoff();
+		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS);
+		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS);
+		resetBackoff(state);
 		expect(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)).toBe(
 			CHANNEL_RECONNECT_DELAYS_MS[0],
-		)
-	})
+		);
+	});
 
-	it('uses the configured 30s ceiling on the last delay', () => {
-		const state = createBackoff()
-		const lastIndex = CHANNEL_RECONNECT_DELAYS_MS.length - 1
+	it("uses the configured 30s ceiling on the last delay", () => {
+		const state = createBackoff();
+		const lastIndex = CHANNEL_RECONNECT_DELAYS_MS.length - 1;
 		for (let i = 0; i < lastIndex; i += 1) {
-			nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
+			nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS);
 		}
-		expect(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)).toBe(30_000)
-		expect(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)).toBe(30_000)
-	})
-})
+		expect(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)).toBe(30_000);
+		expect(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)).toBe(30_000);
+	});
+});

package/frontend-vue/tests/channel-client.test.ts

@@ -1,48 +1,48 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from "vitest";
 import {
 	type ChannelStatus,
 	createChannelClient,
-} from '../app/runtime/channel-client'
-import { CHANNEL_RECONNECT_DELAYS_MS } from '../app/runtime/constants'
+} from "../app/runtime/channel-client";
+import { CHANNEL_RECONNECT_DELAYS_MS } from "../app/runtime/constants";
 
 interface FakeStream {
-	path: string
-	emit: (name: string, data: string) => void
-	end: () => void
+	path: string;
+	emit: (name: string, data: string) => void;
+	end: () => void;
 }
 
 interface Harness {
-	streams: FakeStream[]
-	posts: Array<{ path: string; body: unknown }>
-	statuses: ChannelStatus[]
-	ready: ReturnType<typeof vi.fn>
-	frames: string[]
+	streams: FakeStream[];
+	posts: Array<{ path: string; body: unknown }>;
+	statuses: ChannelStatus[];
+	ready: ReturnType<typeof vi.fn>;
+	frames: string[];
 }
 
-const encoder = new TextEncoder()
-const READY = '{"connections":{"host":"h-1","chat":"c 1"}}'
+const encoder = new TextEncoder();
+const READY = '{"connectionId":"c 1"}';
 
 function openFakeStream(
 	streams: FakeStream[],
 	path: string,
 	signal: AbortSignal,
 ): Promise<Response> {
-	let controller!: ReadableStreamDefaultController<Uint8Array>
+	let controller!: ReadableStreamDefaultController<Uint8Array>;
 	const body = new ReadableStream<Uint8Array>({
 		start: (c) => {
-			controller = c
+			controller = c;
 		},
-	})
-	signal.addEventListener('abort', () =>
-		controller.error(new DOMException('aborted', 'AbortError')),
-	)
+	});
+	signal.addEventListener("abort", () =>
+		controller.error(new DOMException("aborted", "AbortError")),
+	);
 	streams.push({
 		path,
 		emit: (name, data) =>
 			controller.enqueue(encoder.encode(`event: ${name}\ndata: ${data}\n\n`)),
 		end: () => controller.close(),
-	})
-	return Promise.resolve(new Response(body, { status: 200 }))
+	});
+	return Promise.resolve(new Response(body, { status: 200 }));
 }
 
 function startClient(post = vi.fn(async () => undefined)) {
@@ -52,196 +52,195 @@ function startClient(post = vi.fn(async () => undefined)) {
 		statuses: [],
 		ready: vi.fn(),
 		frames: [],
-	}
+	};
 	const client = createChannelClient({
-		channels: ['host', 'chat'],
 		post: async (path, body) => {
-			harness.posts.push({ path, body })
-			return post(path, body)
+			harness.posts.push({ path, body });
+			return post(path, body);
 		},
 		openStream: (path, signal) => openFakeStream(harness.streams, path, signal),
 		onReady: harness.ready,
-		onFrame: (channel, raw) => harness.frames.push(`${channel} ${raw}`),
+		onFrame: (raw) => harness.frames.push(raw),
 		onStatusChange: (status) => harness.statuses.push(status),
-	})
-	client.start()
-	return { client, harness }
+	});
+	client.start();
+	return { client, harness };
 }
 
 async function flush(): Promise<void> {
-	for (let i = 0; i < 10; i += 1) await Promise.resolve()
-	await new Promise((resolve) => setTimeout(resolve, 0))
+	for (let i = 0; i < 10; i += 1) await Promise.resolve();
+	await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
 afterEach(() => {
-	vi.useRealTimers()
-})
+	vi.useRealTimers();
+});
 
-describe('channel client', () => {
-	it('stays closed until started', async () => {
-		const streams: FakeStream[] = []
+describe("channel client", () => {
+	it("stays closed until started", async () => {
+		const streams: FakeStream[] = [];
 		const client = createChannelClient({
-			channels: ['host', 'chat'],
 			post: vi.fn(),
 			openStream: (path, signal) => openFakeStream(streams, path, signal),
-		})
-		await flush()
-		expect(streams).toEqual([])
-		expect(client.getStatus()).toBe('disconnected')
-	})
-
-	it('opens one stream for every channel, on the dashboard origin, with no credential', async () => {
-		const { client, harness } = startClient()
-		await flush()
+		});
+		await flush();
+		expect(streams).toEqual([]);
+		expect(client.getStatus()).toBe("disconnected");
+	});
+
+	it("opens one stream for the dashboard and its chat, on the dashboard origin, with no credential", async () => {
+		const { client, harness } = startClient();
+		await flush();
 		expect(harness.streams.map((stream) => stream.path)).toEqual([
-			'/ai/channels/host,chat/events',
-		])
-		client.stop()
-	})
-
-	it('announces the connection, then routes each frame by channel, raw', async () => {
-		const { client, harness } = startClient()
-		await flush()
-		harness.streams[0]?.emit('ready', READY)
-		harness.streams[0]?.emit('host', '{"type":"host_command_navigate","path":"/x"}')
-		harness.streams[0]?.emit('chat', '{"type":"run_done"}')
-		harness.streams[0]?.emit('unknown', '{}')
-		await flush()
-		expect(harness.ready).toHaveBeenCalledTimes(1)
-		expect(client.isConnected()).toBe(true)
+			"/ai/channel/events",
+		]);
+		client.stop();
+	});
+
+	it("announces the connection, then hands over every frame raw, whoever it is for", async () => {
+		const { client, harness } = startClient();
+		await flush();
+		harness.streams[0]?.emit("ready", READY);
+		harness.streams[0]?.emit(
+			"message",
+			'{"type":"host_command_navigate","path":"/x"}',
+		);
+		harness.streams[0]?.emit("message", '{"type":"run_done"}');
+		harness.streams[0]?.emit("unknown", "{}");
+		await flush();
+		expect(harness.ready).toHaveBeenCalledTimes(1);
+		expect(client.isConnected()).toBe(true);
 		expect(harness.frames).toEqual([
-			'host {"type":"host_command_navigate","path":"/x"}',
-			'chat {"type":"run_done"}',
-		])
-		client.stop()
-	})
-
-	it('posts one message at a time, in order, to the connection of its channel', async () => {
-		const pending: Array<() => void> = []
+			'{"type":"host_command_navigate","path":"/x"}',
+			'{"type":"run_done"}',
+		]);
+		client.stop();
+	});
+
+	it("posts one message at a time, in order, to the connection", async () => {
+		const pending: Array<() => void> = [];
 		const post = vi.fn(
 			() => new Promise<void>((resolve) => pending.push(() => resolve())),
-		)
-		const { client, harness } = startClient(post)
-		await flush()
-		harness.streams[0]?.emit('ready', READY)
-		await flush()
-		client.send('chat', { n: 1 })
-		client.send('host', { n: 2 })
-		await flush()
+		);
+		const { client, harness } = startClient(post);
+		await flush();
+		harness.streams[0]?.emit("ready", READY);
+		await flush();
+		client.send({ n: 1 });
+		client.send({ n: 2 });
+		await flush();
 		expect(harness.posts).toEqual([
-			{ path: '/ai/channels/c%201/messages', body: { n: 1 } },
-		])
-		pending.shift()?.()
-		await flush()
+			{ path: "/ai/channel/c%201/messages", body: { n: 1 } },
+		]);
+		pending.shift()?.();
+		await flush();
 		expect(harness.posts.at(-1)).toEqual({
-			path: '/ai/channels/h-1/messages',
+			path: "/ai/channel/c%201/messages",
 			body: { n: 2 },
-		})
-		client.stop()
-	})
-
-	it('drops a message sent before the connection is ready, and says so', async () => {
-		const { client, harness } = startClient()
-		expect(client.send('chat', { n: 1 })).toBe(false)
-		await flush()
-		expect(harness.posts).toEqual([])
-		harness.streams[0]?.emit('ready', READY)
-		await flush()
-		expect(client.send('chat', { n: 2 })).toBe(true)
-		client.stop()
-	})
-
-	it('refuses a message for a channel the stream does not carry', async () => {
-		const { client, harness } = startClient()
-		await flush()
-		harness.streams[0]?.emit('ready', READY)
-		await flush()
-		expect(client.send('unknown', { n: 1 })).toBe(false)
-		await flush()
-		expect(harness.posts).toEqual([])
-		client.stop()
-	})
-
-	it('reconnects with backoff when the stream ends, and announces the new connection', async () => {
-		vi.useFakeTimers()
-		const { client, harness } = startClient()
-		await vi.advanceTimersByTimeAsync(0)
-		harness.streams[0]?.emit('ready', READY)
-		await vi.advanceTimersByTimeAsync(0)
-		harness.streams[0]?.end()
-		await vi.advanceTimersByTimeAsync(0)
-		expect(client.isConnected()).toBe(false)
-		expect(harness.statuses).toEqual(['connecting', 'connected', 'reconnecting'])
-		await vi.advanceTimersByTimeAsync(CHANNEL_RECONNECT_DELAYS_MS[0])
-		harness.streams[1]?.emit('ready', READY)
-		await vi.advanceTimersByTimeAsync(0)
-		expect(harness.streams).toHaveLength(2)
-		expect(harness.ready).toHaveBeenCalledTimes(2)
-		expect(harness.statuses.at(-1)).toBe('connected')
-		client.stop()
-	})
-
-	it('drops the connection and reconnects when a post fails', async () => {
-		vi.useFakeTimers()
+		});
+		client.stop();
+	});
+
+	it("drops a message sent before the connection is ready, and says so", async () => {
+		const { client, harness } = startClient();
+		expect(client.send({ n: 1 })).toBe(false);
+		await flush();
+		expect(harness.posts).toEqual([]);
+		harness.streams[0]?.emit("ready", READY);
+		await flush();
+		expect(client.send({ n: 2 })).toBe(true);
+		client.stop();
+	});
+
+	it("reconnects with backoff when the stream ends, and announces the new connection", async () => {
+		vi.useFakeTimers();
+		const { client, harness } = startClient();
+		await vi.advanceTimersByTimeAsync(0);
+		harness.streams[0]?.emit("ready", READY);
+		await vi.advanceTimersByTimeAsync(0);
+		harness.streams[0]?.end();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(client.isConnected()).toBe(false);
+		expect(harness.statuses).toEqual([
+			"connecting",
+			"connected",
+			"reconnecting",
+		]);
+		await vi.advanceTimersByTimeAsync(CHANNEL_RECONNECT_DELAYS_MS[0]);
+		harness.streams[1]?.emit("ready", READY);
+		await vi.advanceTimersByTimeAsync(0);
+		expect(harness.streams).toHaveLength(2);
+		expect(harness.ready).toHaveBeenCalledTimes(2);
+		expect(harness.statuses.at(-1)).toBe("connected");
+		client.stop();
+	});
+
+	it("drops the connection and reconnects when a post fails", async () => {
+		vi.useFakeTimers();
 		const post = vi.fn(async () => {
-			throw new Error('404')
-		})
-		const { client, harness } = startClient(post)
-		await vi.advanceTimersByTimeAsync(0)
-		harness.streams[0]?.emit('ready', READY)
-		await vi.advanceTimersByTimeAsync(0)
-		client.send('chat', { n: 1 })
-		await vi.advanceTimersByTimeAsync(0)
-		expect(client.getStatus()).toBe('reconnecting')
-		await vi.advanceTimersByTimeAsync(CHANNEL_RECONNECT_DELAYS_MS[0])
-		expect(harness.streams).toHaveLength(2)
-		client.stop()
-	})
-
-	it('says connecting while reconnectNow replaces a live stream, until the new one is ready', async () => {
-		const { client, harness } = startClient()
-		await flush()
-		harness.streams[0]?.emit('ready', READY)
-		await flush()
-		client.reconnectNow()
-		await flush()
-		expect(client.getStatus()).toBe('connecting')
-		expect(client.send('chat', { n: 1 })).toBe(false)
-		harness.streams[1]?.emit('ready', READY)
-		await flush()
-		expect(harness.statuses).toEqual(['connecting', 'connected', 'connecting', 'connected'])
-		expect(harness.ready).toHaveBeenCalledTimes(2)
-		client.stop()
-	})
-
-	it('skips the backoff on reconnectNow', async () => {
-		vi.useFakeTimers()
-		const { client, harness } = startClient()
-		await vi.advanceTimersByTimeAsync(0)
-		harness.streams[0]?.end()
-		await vi.advanceTimersByTimeAsync(0)
-		client.reconnectNow()
-		await vi.advanceTimersByTimeAsync(0)
-		expect(harness.streams).toHaveLength(2)
-		client.stop()
-	})
-
-	it('stops reconnecting once stopped, and opens again on start', async () => {
-		vi.useFakeTimers()
-		const { client, harness } = startClient()
-		await vi.advanceTimersByTimeAsync(0)
-		client.stop()
+			throw new Error("404");
+		});
+		const { client, harness } = startClient(post);
+		await vi.advanceTimersByTimeAsync(0);
+		harness.streams[0]?.emit("ready", READY);
+		await vi.advanceTimersByTimeAsync(0);
+		client.send({ n: 1 });
+		await vi.advanceTimersByTimeAsync(0);
+		expect(client.getStatus()).toBe("reconnecting");
+		await vi.advanceTimersByTimeAsync(CHANNEL_RECONNECT_DELAYS_MS[0]);
+		expect(harness.streams).toHaveLength(2);
+		client.stop();
+	});
+
+	it("says connecting while reconnectNow replaces a live stream, until the new one is ready", async () => {
+		const { client, harness } = startClient();
+		await flush();
+		harness.streams[0]?.emit("ready", READY);
+		await flush();
+		client.reconnectNow();
+		await flush();
+		expect(client.getStatus()).toBe("connecting");
+		expect(client.send({ n: 1 })).toBe(false);
+		harness.streams[1]?.emit("ready", READY);
+		await flush();
+		expect(harness.statuses).toEqual([
+			"connecting",
+			"connected",
+			"connecting",
+			"connected",
+		]);
+		expect(harness.ready).toHaveBeenCalledTimes(2);
+		client.stop();
+	});
+
+	it("skips the backoff on reconnectNow", async () => {
+		vi.useFakeTimers();
+		const { client, harness } = startClient();
+		await vi.advanceTimersByTimeAsync(0);
+		harness.streams[0]?.end();
+		await vi.advanceTimersByTimeAsync(0);
+		client.reconnectNow();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(harness.streams).toHaveLength(2);
+		client.stop();
+	});
+
+	it("stops reconnecting once stopped, and opens again on start", async () => {
+		vi.useFakeTimers();
+		const { client, harness } = startClient();
+		await vi.advanceTimersByTimeAsync(0);
+		client.stop();
 		await vi.advanceTimersByTimeAsync(
 			CHANNEL_RECONNECT_DELAYS_MS[CHANNEL_RECONNECT_DELAYS_MS.length - 1] * 2,
-		)
-		expect(harness.streams).toHaveLength(1)
-		expect(client.getStatus()).toBe('disconnected')
-		client.reconnectNow()
-		await vi.advanceTimersByTimeAsync(0)
-		expect(harness.streams).toHaveLength(1)
-		client.start()
-		await vi.advanceTimersByTimeAsync(0)
-		expect(harness.streams).toHaveLength(2)
-		client.stop()
-	})
-})
+		);
+		expect(harness.streams).toHaveLength(1);
+		expect(client.getStatus()).toBe("disconnected");
+		client.reconnectNow();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(harness.streams).toHaveLength(1);
+		client.start();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(harness.streams).toHaveLength(2);
+		client.stop();
+	});
+});