@antelopejs/dms-ai 0.1.2 → 0.1.3

package/frontend-vue/app/runtime/theme-bridge.ts

@@ -1,7 +1,8 @@
 // Theme bridge (host → chatbox iframe). The host DMS is the source of truth for
 // the active Nuxt UI primary palette and the light/dark mode; the chatbox iframe
-// is a separate document (different origin) so it cannot inherit them through
-// CSS — we forward them explicitly here.
+// is a separate document, so it cannot inherit them through CSS — we forward
+// them explicitly here. Both documents share the dashboard's origin, which is
+// the only one either side posts to or accepts messages from.
 //
 // Protocol:
 //   iframe → host : { type: "dms-ai:ready" }            (chatbox announces mount)
@@ -113,6 +114,17 @@ interface MessageData {
 
 type ThemePush = (force: boolean) => void
 
+/** True for a message the chatbox frame itself posted, from our own origin. */
+export function isFromFrame(
+	event: MessageEvent,
+	iframe: HTMLIFrameElement,
+): boolean {
+	return (
+		event.source === iframe.contentWindow &&
+		event.origin === globalThis.location.origin
+	)
+}
+
 // Only answer the handshake from our own iframe, never an arbitrary frame.
 function answerReadyHandshake(
 	iframe: HTMLIFrameElement,
@@ -120,7 +132,7 @@ function answerReadyHandshake(
 ): void {
 	globalThis.addEventListener('message', (event: MessageEvent) => {
 		const type = (event.data as MessageData)?.type
-		if (type === READY_MESSAGE_TYPE && event.source === iframe.contentWindow) {
+		if (type === READY_MESSAGE_TYPE && isFromFrame(event, iframe)) {
 			post(true)
 		}
 	})
@@ -165,7 +177,7 @@ export function installThemeBridge(
 		onTheme?.(theme)
 		iframe.contentWindow?.postMessage(
 			{ type: THEME_MESSAGE_TYPE, ...theme },
-			'*',
+			globalThis.location.origin,
 		)
 	}
 

package/frontend-vue/package.json

@@ -5,6 +5,9 @@
 	"type": "module",
 	"license": "Apache-2.0",
 	"packageManager": "pnpm@10.6.5",
+	"engines": {
+		"@antelopejs/dms-frontend": ">=0.2.8 <0.4.0"
+	},
 	"scripts": {
 		"build": "pnpm --dir \"${DMS_FRONTEND_WORKSPACE:?Set DMS_FRONTEND_WORKSPACE to the generated Inertia workspace}\" build",
 		"typecheck": "pnpm --dir \"${DMS_FRONTEND_WORKSPACE:?Set DMS_FRONTEND_WORKSPACE to the generated Inertia workspace}\" typecheck",

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

@@ -4,41 +4,41 @@ import {
 	nextDelay,
 	resetBackoff,
 } from '../app/runtime/backoff'
-import { WS_RECONNECT_DELAYS_MS } from '../app/runtime/constants'
+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[] = []
-		for (let i = 0; i < WS_RECONNECT_DELAYS_MS.length + 3; i += 1) {
-			observed.push(nextDelay(state, WS_RECONNECT_DELAYS_MS))
+		for (let i = 0; i < CHANNEL_RECONNECT_DELAYS_MS.length + 3; i += 1) {
+			observed.push(nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS))
 		}
 		const expected = [
-			...WS_RECONNECT_DELAYS_MS,
-			WS_RECONNECT_DELAYS_MS[WS_RECONNECT_DELAYS_MS.length - 1],
-			WS_RECONNECT_DELAYS_MS[WS_RECONNECT_DELAYS_MS.length - 1],
-			WS_RECONNECT_DELAYS_MS[WS_RECONNECT_DELAYS_MS.length - 1],
+			...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)
 	})
 
 	it('resetBackoff returns the schedule to schedule[0]', () => {
 		const state = createBackoff()
-		nextDelay(state, WS_RECONNECT_DELAYS_MS)
-		nextDelay(state, WS_RECONNECT_DELAYS_MS)
+		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
+		nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
 		resetBackoff(state)
-		expect(nextDelay(state, WS_RECONNECT_DELAYS_MS)).toBe(
-			WS_RECONNECT_DELAYS_MS[0],
+		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 = WS_RECONNECT_DELAYS_MS.length - 1
+		const lastIndex = CHANNEL_RECONNECT_DELAYS_MS.length - 1
 		for (let i = 0; i < lastIndex; i += 1) {
-			nextDelay(state, WS_RECONNECT_DELAYS_MS)
+			nextDelay(state, CHANNEL_RECONNECT_DELAYS_MS)
 		}
-		expect(nextDelay(state, WS_RECONNECT_DELAYS_MS)).toBe(30_000)
-		expect(nextDelay(state, WS_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

@@ -0,0 +1,247 @@
+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'
+
+interface FakeStream {
+	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[]
+}
+
+const encoder = new TextEncoder()
+const READY = '{"connections":{"host":"h-1","chat":"c 1"}}'
+
+function openFakeStream(
+	streams: FakeStream[],
+	path: string,
+	signal: AbortSignal,
+): Promise<Response> {
+	let controller!: ReadableStreamDefaultController<Uint8Array>
+	const body = new ReadableStream<Uint8Array>({
+		start: (c) => {
+			controller = c
+		},
+	})
+	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 }))
+}
+
+function startClient(post = vi.fn(async () => undefined)) {
+	const harness: Harness = {
+		streams: [],
+		posts: [],
+		statuses: [],
+		ready: vi.fn(),
+		frames: [],
+	}
+	const client = createChannelClient({
+		channels: ['host', 'chat'],
+		post: async (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}`),
+		onStatusChange: (status) => harness.statuses.push(status),
+	})
+	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))
+}
+
+afterEach(() => {
+	vi.useRealTimers()
+})
+
+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()
+		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)
+		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> = []
+		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()
+		expect(harness.posts).toEqual([
+			{ path: '/ai/channels/c%201/messages', body: { n: 1 } },
+		])
+		pending.shift()?.()
+		await flush()
+		expect(harness.posts.at(-1)).toEqual({
+			path: '/ai/channels/h-1/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()
+		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()
+		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()
+	})
+})

package/frontend-vue/tests/chat-transport.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+	createChatTransport,
+	exposeChatTransport,
+} from '../app/runtime/chat-transport'
+import { CHAT_TRANSPORT_KEY } from '../app/runtime/constants'
+
+function hub() {
+	const actions = {
+		send: vi.fn(() => true),
+		reconnect: vi.fn(),
+		getStatus: vi.fn(() => 'connected' as const),
+	}
+	return { actions, chat: createChatTransport(actions) }
+}
+
+describe('chat transport', () => {
+	it('lends the chat its channel: frames, readiness and status in, messages out', () => {
+		const { actions, chat } = hub()
+		const frames: string[] = []
+		const statuses: string[] = []
+		const ready = vi.fn()
+		chat.transport.onFrame((raw) => frames.push(raw))
+		chat.transport.onStatus((status) => statuses.push(status))
+		chat.transport.onReady(ready)
+		chat.deliverFrame('{"type":"run_done"}')
+		chat.announceStatus('reconnecting')
+		chat.announceReady()
+		expect(chat.transport.send({ type: 'hello' })).toBe(true)
+		chat.transport.reconnect()
+		expect(frames).toEqual(['{"type":"run_done"}'])
+		expect(statuses).toEqual(['reconnecting'])
+		expect(ready).toHaveBeenCalledTimes(1)
+		expect(actions.send).toHaveBeenCalledWith({ type: 'hello' })
+		expect(actions.reconnect).toHaveBeenCalledTimes(1)
+		expect(chat.transport.getStatus()).toBe('connected')
+	})
+
+	it('stops delivering to a listener once it unsubscribed', () => {
+		const { chat } = hub()
+		const frames: string[] = []
+		const unsubscribe = chat.transport.onFrame((raw) => frames.push(raw))
+		unsubscribe()
+		chat.deliverFrame('{}')
+		expect(frames).toEqual([])
+	})
+
+	it('keeps delivering when one listener throws, as a gone chat document would', () => {
+		const { chat } = hub()
+		const frames: string[] = []
+		const error = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+		chat.transport.onFrame(() => {
+			throw new Error('dead document')
+		})
+		chat.transport.onFrame((raw) => frames.push(raw))
+		chat.deliverFrame('{}')
+		expect(frames).toEqual(['{}'])
+		error.mockRestore()
+	})
+
+	it('publishes itself where the same-origin chat document looks', () => {
+		const { chat } = hub()
+		exposeChatTransport(chat.transport)
+		expect(Reflect.get(globalThis, CHAT_TRANSPORT_KEY)).toBe(chat.transport)
+		Reflect.deleteProperty(globalThis, CHAT_TRANSPORT_KEY)
+	})
+})

package/frontend-vue/tests/sidecar-status.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createSidecarStatusController } from '../app/runtime/sidecar-status'
+
+describe('sidecar status', () => {
+	it('reports connected from the status alone, and keeps no port or credential', async () => {
+		const controller = createSidecarStatusController(async () => ({
+			isRunning: true,
+		}))
+		expect(await controller.init()).toBe(true)
+		expect(controller.getStatus()).toBe('connected')
+		expect(Object.keys(controller)).not.toContain('getPort')
+		expect(Object.keys(controller)).not.toContain('getClientToken')
+		controller.dispose()
+	})
+
+	it('re-probes when the channel drops, and reports connected once the sidecar answers', async () => {
+		const fetchInfo = vi
+			.fn()
+			.mockResolvedValueOnce({ isRunning: true })
+			.mockResolvedValueOnce({ isRunning: true })
+		const statuses: string[] = []
+		const controller = createSidecarStatusController(fetchInfo)
+		await controller.init()
+		controller.subscribe((status) => statuses.push(status))
+		controller.reportChannelDown()
+		await vi.waitFor(() => expect(statuses.at(-1)).toBe('connected'))
+		expect(statuses).toEqual(['connected', 'reviving', 'connected'])
+		expect(fetchInfo).toHaveBeenCalledTimes(2)
+		controller.dispose()
+	})
+
+	it('does not show the assistant when spawning is disabled', async () => {
+		const controller = createSidecarStatusController(async () => ({
+			disabled: true,
+		}))
+		expect(await controller.init()).toBe(false)
+		controller.dispose()
+	})
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-ai",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -34,12 +34,13 @@
     "prepack": "pnpm run build && pnpm run build:sidecar",
     "frontend:dev": "cd playground && pnpm frontend:dev",
     "dev": "cd playground && pnpm dev",
-    "lint": "oxlint --disable-nested-config && oxfmt --disable-nested-config --check . && cd frontend-vue && pnpm lint && cd ../sidecar && pnpm lint",
+    "lint": "oxlint --disable-nested-config && oxfmt --disable-nested-config --check . && cd frontend-vue && pnpm lint && cd ../sidecar && pnpm lint && antelopejs-check-interface-ranges",
     "lint:fix": "oxlint --disable-nested-config --fix --max-warnings=1000000 && oxfmt --disable-nested-config . && cd frontend-vue && pnpm lint:fix && cd ../sidecar && pnpm lint:fix",
     "typecheck": "tsc --noEmit && cd frontend-vue && pnpm typecheck && cd ../sidecar && pnpm typecheck",
     "test": "cd sidecar && pnpm test && cd ../frontend-vue && pnpm test",
     "test:sidecar-smoke": "pnpm run build:sidecar && node --test tests/sidecar-build.test.cjs",
     "test:frontend-registration": "pnpm run build && node --test tests/frontend-registration.test.cjs",
+    "test:channels": "pnpm run build && node --test tests/channels.test.cjs tests/channel-limits.test.cjs",
     "test:spawn-args": "node --test tests/spawn-args.test.cjs",
     "test:release-script": "node --test tests/release-script.test.cjs",
     "test:e2e": "cd sidecar && pnpm test:e2e",
@@ -59,8 +60,9 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@antelopejs/tooling-configs": ">=0.0.6 <1.0.0",
+    "@antelopejs/tooling-configs": ">=0.0.7 <1.0.0",
     "@types/node": "^24.0.0",
+    "@types/ws": "^8.5.12",
     "knip": "^6.34.0",
     "oxfmt": "^0.66.0",
     "oxlint": "1.81.0",