@antelopejs/dms-ai 0.0.1

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import {
+	createBackoff,
+	nextDelay,
+	resetBackoff,
+} from '../app/runtime/backoff'
+import { WS_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))
+		}
+		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],
+		]
+		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)
+		resetBackoff(state)
+		expect(nextDelay(state, WS_RECONNECT_DELAYS_MS)).toBe(
+			WS_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
+		for (let i = 0; i < lastIndex; i += 1) {
+			nextDelay(state, WS_RECONNECT_DELAYS_MS)
+		}
+		expect(nextDelay(state, WS_RECONNECT_DELAYS_MS)).toBe(30_000)
+		expect(nextDelay(state, WS_RECONNECT_DELAYS_MS)).toBe(30_000)
+	})
+})

package/frontend-vue/tests/host-commands.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+	createHostCommandDispatcher,
+	type DevReloadWaiter,
+} from '../app/runtime/host-commands'
+
+function navigateCommand(path: string): string {
+	return JSON.stringify({ type: 'host_command_navigate', path })
+}
+
+interface ControlledWaiter {
+	waiter: DevReloadWaiter
+	calls: string[]
+	release: (path: string, served?: boolean) => void
+	reject: (path: string, err: Error) => void
+}
+
+function controlledWaiter(): ControlledWaiter {
+	const calls: string[] = []
+	const settlers = new Map<
+		string,
+		{ resolve: (served: boolean) => void; reject: (err: Error) => void }
+	>()
+	return {
+		calls,
+		release: (path, served = true) => settlers.get(path)?.resolve(served),
+		reject: (path, err) => settlers.get(path)?.reject(err),
+		waiter: {
+			awaitRoute: (path) => {
+				calls.push(path)
+				return new Promise<boolean>((resolve, reject) => {
+					settlers.set(path, { resolve, reject })
+				})
+			},
+		},
+	}
+}
+
+describe('host command dispatch', () => {
+	it('navigates only once the dev reload serves the target route', async () => {
+		const push = vi.fn()
+		const { waiter, calls, release } = controlledWaiter()
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: waiter,
+		})
+		dispatch(navigateCommand('/new-page'))
+		await vi.waitFor(() => expect(calls).toEqual(['/new-page']))
+		expect(push).not.toHaveBeenCalled()
+		release('/new-page')
+		await vi.waitFor(() =>
+			expect(push).toHaveBeenCalledExactlyOnceWith('/new-page'),
+		)
+	})
+
+	it('navigates anyway when the route never comes back', async () => {
+		const push = vi.fn()
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: { awaitRoute: async () => false },
+		})
+		dispatch(navigateCommand('/deleted'))
+		await vi.waitFor(() =>
+			expect(push).toHaveBeenCalledExactlyOnceWith('/deleted'),
+		)
+	})
+
+	it('navigates anyway when the dev reload wait rejects', async () => {
+		const push = vi.fn()
+		const error = new Error('dev reload exploded')
+		const { waiter, calls, reject } = controlledWaiter()
+		const logged = vi.spyOn(console, 'error').mockImplementation(() => {})
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: waiter,
+		})
+		dispatch(navigateCommand('/broken-wait'))
+		await vi.waitFor(() => expect(calls).toEqual(['/broken-wait']))
+		reject('/broken-wait', error)
+		await vi.waitFor(() =>
+			expect(push).toHaveBeenCalledExactlyOnceWith('/broken-wait'),
+		)
+		expect(logged).toHaveBeenCalledWith(
+			expect.stringContaining('/broken-wait'),
+			error,
+		)
+		logged.mockRestore()
+	})
+
+	it('collapses a burst into a single trip to the newest path', async () => {
+		const push = vi.fn()
+		const { waiter, calls, release } = controlledWaiter()
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: waiter,
+		})
+		dispatch(navigateCommand('/stale'))
+		dispatch(navigateCommand('/fresh'))
+		await vi.waitFor(() => expect(calls).toEqual(['/fresh']))
+		release('/fresh')
+		await vi.waitFor(() =>
+			expect(push).toHaveBeenCalledExactlyOnceWith('/fresh'),
+		)
+	})
+
+	it('keeps navigations in order when one arrives mid-wait', async () => {
+		const push = vi.fn()
+		const { waiter, calls, release } = controlledWaiter()
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: waiter,
+		})
+		dispatch(navigateCommand('/first'))
+		await vi.waitFor(() => expect(calls).toEqual(['/first']))
+		dispatch(navigateCommand('/second'))
+		// The second command must not overtake the first while it is still waiting.
+		expect(calls).toEqual(['/first'])
+		release('/first')
+		await vi.waitFor(() => expect(calls).toEqual(['/first', '/second']))
+		expect(push.mock.calls.flat()).toEqual(['/first'])
+		release('/second')
+		await vi.waitFor(() =>
+			expect(push.mock.calls.flat()).toEqual(['/first', '/second']),
+		)
+	})
+
+	it('ignores malformed payloads and unknown command types', async () => {
+		const push = vi.fn()
+		const awaitRoute = vi.fn(async () => true)
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: { awaitRoute },
+		})
+		const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+		dispatch('not json')
+		dispatch(JSON.stringify({ type: 'host_command_unknown' }))
+		expect(push).not.toHaveBeenCalled()
+		expect(awaitRoute).not.toHaveBeenCalled()
+		expect(warn).toHaveBeenCalledOnce()
+		warn.mockRestore()
+	})
+})

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

@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from 'vitest'
+import { installCurrentPageTracker } from '../app/runtime/current-page'
+import { installNavigationCompleteEmitter } from '../app/runtime/navigation-complete'
+
+function navigate(url: string): void {
+	document.dispatchEvent(
+		new CustomEvent('inertia:navigate', {
+			detail: { page: { url } },
+		}),
+	)
+}
+
+describe('Inertia host navigation', () => {
+	it('reports the initial pathname and completed visits, then unsubscribes', () => {
+		window.history.replaceState({}, '', '/initial?tab=one#section')
+		const send = vi.fn()
+		const stop = installCurrentPageTracker({ send })
+		expect(send).toHaveBeenLastCalledWith({
+			type: 'host_state_update',
+			currentPage: { path: '/initial' },
+		})
+		navigate('/other/deep?tab=two#anchor')
+		expect(send).toHaveBeenLastCalledWith({
+			type: 'host_state_update',
+			currentPage: { path: '/other/deep' },
+		})
+		stop()
+		navigate('/ignored')
+		expect(send).toHaveBeenCalledTimes(2)
+	})
+
+	it('emits completion only after navigation and removes its event listener', () => {
+		const send = vi.fn()
+		const stop = installNavigationCompleteEmitter({ send })
+		expect(send).not.toHaveBeenCalled()
+		navigate('https://example.test/finished?view=graph#node')
+		expect(send).toHaveBeenCalledExactlyOnceWith({
+			type: 'host_navigation_complete',
+			path: '/finished',
+		})
+		stop()
+		navigate('/ignored')
+		expect(send).toHaveBeenCalledTimes(1)
+	})
+})

package/frontend-vue/tests/overlay-prefs.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+	OVERLAY_PREFS_DEBOUNCE_MS,
+	OVERLAY_PREFS_STORAGE_KEY,
+} from '../app/runtime/constants'
+import {
+	flushPrefsForTesting,
+	type OverlayPrefs,
+	readPrefs,
+	resetPrefsForTesting,
+	writePrefsDebounced,
+} from '../app/runtime/overlay-prefs'
+
+const SAMPLE_PREFS: OverlayPrefs = {
+	width: 400,
+	isOpen: false,
+}
+
+const FIRST_PREFS: OverlayPrefs = {
+	width: 300,
+	isOpen: false,
+}
+
+const SECOND_PREFS: OverlayPrefs = {
+	width: 320,
+	isOpen: false,
+}
+
+const FINAL_PREFS: OverlayPrefs = {
+	width: 360,
+	isOpen: true,
+}
+
+describe('overlay-prefs storage', () => {
+	beforeEach(() => {
+		resetPrefsForTesting()
+	})
+
+	afterEach(() => {
+		resetPrefsForTesting()
+	})
+
+	it('returns null when no prefs are stored', () => {
+		expect(readPrefs()).toBeNull()
+	})
+
+	it('round-trips a prefs object via debounced write then read', () => {
+		writePrefsDebounced(SAMPLE_PREFS)
+		flushPrefsForTesting()
+		expect(readPrefs()).toEqual(SAMPLE_PREFS)
+	})
+
+	it('returns null when the stored payload is malformed JSON', () => {
+		globalThis.localStorage.setItem(OVERLAY_PREFS_STORAGE_KEY, '{not json')
+		expect(readPrefs()).toBeNull()
+	})
+
+	it('returns null when the stored payload is missing fields', () => {
+		globalThis.localStorage.setItem(
+			OVERLAY_PREFS_STORAGE_KEY,
+			JSON.stringify({ x: 0, y: 0 }),
+		)
+		expect(readPrefs()).toBeNull()
+	})
+})
+
+describe('writePrefsDebounced timing', () => {
+	beforeEach(() => {
+		vi.useFakeTimers()
+		resetPrefsForTesting()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+		resetPrefsForTesting()
+	})
+
+	it('does not persist before the debounce window elapses', () => {
+		writePrefsDebounced(FIRST_PREFS)
+		vi.advanceTimersByTime(OVERLAY_PREFS_DEBOUNCE_MS - 1)
+		expect(readPrefs()).toBeNull()
+	})
+
+	it('persists only the last call when invoked rapidly', () => {
+		writePrefsDebounced(FIRST_PREFS)
+		writePrefsDebounced(SECOND_PREFS)
+		writePrefsDebounced(FINAL_PREFS)
+		vi.advanceTimersByTime(OVERLAY_PREFS_DEBOUNCE_MS)
+		expect(readPrefs()).toEqual(FINAL_PREFS)
+	})
+})

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

@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createSidecarStatusController } from '../app/runtime/sidecar-status'
+import { createHostWsClient } from '../app/runtime/ws-client'
+
+class FakeWebSocket extends EventTarget {
+	static OPEN = 1
+	readyState = 0
+	send = vi.fn()
+	close = vi.fn()
+	constructor(
+		public url: string,
+		public protocols?: string | string[],
+	) {
+		super()
+		sockets.push(this)
+	}
+}
+
+const sockets: FakeWebSocket[] = []
+afterEach(() => {
+	sockets.length = 0
+	vi.unstubAllGlobals()
+	vi.useRealTimers()
+})
+
+describe('sidecar client credential lifecycle', () => {
+	it('requires an authenticated bootstrap result and relearns credentials after restart', async () => {
+		const fetchInfo = vi
+			.fn()
+			.mockResolvedValueOnce({
+				port: 41001,
+				clientToken: 'first',
+				isRunning: true,
+			})
+			.mockResolvedValueOnce({
+				port: 41002,
+				clientToken: 'second',
+				isRunning: true,
+			})
+		const controller = createSidecarStatusController(fetchInfo)
+		expect(await controller.init()).toBe(true)
+		expect(controller.getClientToken()).toBe('first')
+		controller.reportWsDown()
+		await vi.waitFor(() => expect(controller.getClientToken()).toBe('second'))
+		expect(controller.getPort()).toBe(41002)
+		controller.dispose()
+	})
+
+	it('does not report a legacy unauthenticated sidecar as connected', async () => {
+		const controller = createSidecarStatusController(async () => ({
+			port: 41001,
+			isRunning: true,
+		}))
+		await controller.init()
+		expect(controller.getStatus()).not.toBe('connected')
+		expect(controller.getClientToken()).toBeNull()
+		controller.dispose()
+	})
+
+	it('sends the credential only as a WS subprotocol and updates it on reconnect', () => {
+		vi.stubGlobal('WebSocket', FakeWebSocket)
+		let token: string | null = 'first'
+		const client = createHostWsClient({
+			sidecarHost: 'localhost',
+			getPort: () => 41001,
+			getClientToken: () => token,
+		})
+		expect(sockets[0]?.protocols).toBe('dms-ai.first')
+		expect(sockets[0]?.url).toBe('ws://localhost:41001/ws/host')
+		sockets[0]?.dispatchEvent(new Event('close'))
+		token = 'second'
+		client.reconnectNow()
+		expect(sockets[1]?.protocols).toBe('dms-ai.second')
+		client.close()
+	})
+
+	it('does not open a socket before a credential is available', () => {
+		vi.stubGlobal('WebSocket', FakeWebSocket)
+		const client = createHostWsClient({
+			sidecarHost: 'localhost',
+			getPort: () => 41001,
+			getClientToken: () => null,
+		})
+		expect(sockets).toHaveLength(0)
+		client.close()
+	})
+})

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

@@ -0,0 +1,45 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import ts from 'typescript'
+import { expect, it, vi } from 'vitest'
+
+interface PluginExports {
+	default: (context: unknown) => Promise<void>
+}
+
+it('does not invoke authenticated fetching or inject the assistant for a guest', async () => {
+	const source = readFileSync(
+		resolve(__dirname, '../app/plugins/ai.client.ts'),
+		'utf8',
+	)
+	const compiled = ts.transpileModule(
+		source
+			.replace('import.meta.env.DEV', 'true')
+			.replace('import.meta.hot', 'undefined'),
+		{
+			compilerOptions: { module: ts.ModuleKind.CommonJS },
+		},
+	)
+	const exports = {} as PluginExports
+	const useAuthFetch = vi.fn(() => {
+		throw new Error('A guest must not enter session recovery')
+	})
+	const requireModule = (name: string) =>
+		name === '#dms-inertia/frontend-module'
+			? { defineDmsPlugin: (plugin: unknown) => plugin }
+			: {}
+	new Function(
+		'require',
+		'exports',
+		'useUserSession',
+		'useAuthFetch',
+		compiled.outputText,
+	)(
+		requireModule,
+		exports,
+		() => ({ loggedIn: { value: false } }),
+		useAuthFetch,
+	)
+	await exports.default({})
+	expect(useAuthFetch).not.toHaveBeenCalled()
+})

package/frontend-vue/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+	test: {
+		environment: 'jsdom',
+		include: ['tests/**/*.test.ts'],
+	},
+})

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@antelopejs/dms-ai",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AntelopeJS/dms-ai.git"
+  },
+  "files": [
+    "dist",
+    "frontend-vue",
+    "skills",
+    "sidecar/dist",
+    "sidecar/chatbox/dist",
+    "sidecar/package.json"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@antelopejs/interface-api": "0.0.13",
+    "@antelopejs/interface-core": "0.0.12",
+    "@antelopejs/interface-dms": ">=0.0.1 <1.0.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.131",
+    "@anthropic-ai/claude-code": "^2.1.131",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@antelopejs/tooling-configs": "^0.0.4",
+    "@types/node": "^24.0.0",
+    "knip": "^6.34.0",
+    "oxfmt": "^0.66.0",
+    "oxlint": "1.81.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "release-it": "^19.2.4",
+    "release-it-changelogen": "^0.1.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
+  },
+  "optionalDependencies": {
+    "@antelopejs/interface-dms-builder": ">=0.0.1 <1.0.0"
+  },
+  "antelopeJs": {
+    "baseUrl": "dist",
+    "implements": [],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "build:sidecar": "cd sidecar && pnpm install && pnpm run build:all",
+    "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: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:frontend-registration": "pnpm run build && node --test tests/frontend-registration.test.cjs",
+    "test:release-script": "node --test tests/release-script.test.cjs",
+    "test:e2e": "cd sidecar && pnpm test:e2e",
+    "release": "pnpm --dir frontend-vue install --frozen-lockfile && pnpm --dir sidecar install --frozen-lockfile && pnpm --dir sidecar/chatbox install --frozen-lockfile && release-it",
+    "format": "oxfmt --disable-nested-config . && cd frontend-vue && pnpm format",
+    "knip": "knip --dependencies",
+    "knip:all": "knip"
+  }
+}