@antelopejs/dms-ai 0.1.4 → 0.1.6

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

@@ -1,142 +1,181 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from "vitest";
 import {
 	createHostCommandDispatcher,
 	type DevReloadWaiter,
-} from '../app/runtime/host-commands'
+} from "../app/runtime/host-commands";
 
-function navigateCommand(path: string): string {
-	return JSON.stringify({ type: 'host_command_navigate', path })
+function navigateCommand(path: string): object {
+	return { type: "host_command_navigate", path };
 }
 
 interface ControlledWaiter {
-	waiter: DevReloadWaiter
-	calls: string[]
-	release: (path: string, served?: boolean) => void
-	reject: (path: string, err: Error) => void
+	waiter: DevReloadWaiter;
+	calls: string[];
+	release: (path: string, served?: boolean) => void;
+	reject: (path: string, err: Error) => void;
 }
 
 function controlledWaiter(): ControlledWaiter {
-	const calls: string[] = []
+	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)
+				calls.push(path);
 				return new Promise<boolean>((resolve, reject) => {
-					settlers.set(path, { 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()
+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')
+		});
+		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'),
-		)
-	})
+			expect(push).toHaveBeenCalledExactlyOnceWith("/new-page"),
+		);
+	});
 
-	it('navigates anyway when the route never comes back', async () => {
-		const push = vi.fn()
+	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'))
+		});
+		dispatch(navigateCommand("/deleted"));
 		await vi.waitFor(() =>
-			expect(push).toHaveBeenCalledExactlyOnceWith('/deleted'),
-		)
-	})
+			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(() => {})
+	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)
+		});
+		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(push).toHaveBeenCalledExactlyOnceWith("/broken-wait"),
+		);
 		expect(logged).toHaveBeenCalledWith(
-			expect.stringContaining('/broken-wait'),
+			expect.stringContaining("/broken-wait"),
 			error,
-		)
-		logged.mockRestore()
-	})
+		);
+		logged.mockRestore();
+	});
 
-	it('collapses a burst into a single trip to the newest path', async () => {
-		const push = vi.fn()
-		const { waiter, calls, release } = controlledWaiter()
+	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')
+		});
+		dispatch(navigateCommand("/stale"));
+		dispatch(navigateCommand("/fresh"));
+		await vi.waitFor(() => expect(calls).toEqual(["/fresh"]));
+		release("/fresh");
 		await vi.waitFor(() =>
-			expect(push).toHaveBeenCalledExactlyOnceWith('/fresh'),
-		)
-	})
+			expect(push).toHaveBeenCalledExactlyOnceWith("/fresh"),
+		);
+	});
 
-	it('keeps navigations in order when one arrives mid-wait', async () => {
-		const push = vi.fn()
-		const { waiter, calls, release } = controlledWaiter()
+	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'))
+		});
+		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')
+		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']),
-		)
-	})
+			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)
+	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()
-	})
-})
+		});
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		dispatch("not an object");
+		dispatch({ type: "host_command_unknown" });
+		expect(push).not.toHaveBeenCalled();
+		expect(awaitRoute).not.toHaveBeenCalled();
+		expect(warn).toHaveBeenCalledOnce();
+		warn.mockRestore();
+	});
+
+	it("never sends the dashboard off its own origin, whatever the agent asks", 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(() => {});
+		for (const path of [
+			"https://attacker.example/steal",
+			"//attacker.example/steal",
+			"/\\attacker.example/steal",
+			"javascript:alert(document.cookie)",
+			"relative/path",
+			"",
+		]) {
+			dispatch(navigateCommand(path));
+		}
+		dispatch({ type: "host_command_navigate", path: 42 });
+		await Promise.resolve();
+		expect(push).not.toHaveBeenCalled();
+		expect(awaitRoute).not.toHaveBeenCalled();
+		warn.mockRestore();
+	});
+
+	it("follows a path of the dashboard, query and hash included", async () => {
+		const push = vi.fn();
+		const dispatch = createHostCommandDispatcher({
+			router: { push },
+			devReload: { awaitRoute: async () => true },
+		});
+		dispatch(navigateCommand("/modules/ai/settings?tab=1#top"));
+		await vi.waitFor(() =>
+			expect(push).toHaveBeenCalledExactlyOnceWith(
+				"/modules/ai/settings?tab=1#top",
+			),
+		);
+	});
+});

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

@@ -1,45 +1,76 @@
-import { describe, expect, it, vi } from 'vitest'
-import { installCurrentPageTracker } from '../app/runtime/current-page'
-import { installNavigationCompleteEmitter } from '../app/runtime/navigation-complete'
+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', {
+		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 })
+async function flushMutations(): Promise<void> {
+	await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+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("carries the document title and reports a title rendered after navigation", async () => {
+		window.history.replaceState({}, "", "/orders");
+		document.title = "Orders";
+		const send = vi.fn();
+		const stop = installCurrentPageTracker({ send });
 		expect(send).toHaveBeenLastCalledWith({
-			type: 'host_state_update',
-			currentPage: { path: '/initial' },
-		})
-		navigate('/other/deep?tab=two#anchor')
+			type: "host_state_update",
+			currentPage: { path: "/orders", title: "Orders" },
+		});
+		navigate("/customers");
+		document.title = "Customers";
+		await flushMutations();
 		expect(send).toHaveBeenLastCalledWith({
-			type: 'host_state_update',
-			currentPage: { path: '/other/deep' },
-		})
-		stop()
-		navigate('/ignored')
-		expect(send).toHaveBeenCalledTimes(2)
-	})
+			type: "host_state_update",
+			currentPage: { path: "/customers", title: "Customers" },
+		});
+		const sentCount = send.mock.calls.length;
+		document.title = "Customers";
+		await flushMutations();
+		expect(send).toHaveBeenCalledTimes(sentCount);
+		stop();
+		document.title = "Ignored";
+		await flushMutations();
+		expect(send).toHaveBeenCalledTimes(sentCount);
+		document.title = "";
+	});
 
-	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')
+	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)
-	})
-})
+			type: "host_navigation_complete",
+			path: "/finished",
+		});
+		stop();
+		navigate("/ignored");
+		expect(send).toHaveBeenCalledTimes(1);
+	});
+});

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

@@ -1,91 +1,91 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
 	OVERLAY_PREFS_DEBOUNCE_MS,
 	OVERLAY_PREFS_STORAGE_KEY,
-} from '../app/runtime/constants'
+} from "../app/runtime/constants";
 import {
 	flushPrefsForTesting,
 	type OverlayPrefs,
 	readPrefs,
 	resetPrefsForTesting,
 	writePrefsDebounced,
-} from '../app/runtime/overlay-prefs'
+} 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', () => {
+describe("overlay-prefs storage", () => {
 	beforeEach(() => {
-		resetPrefsForTesting()
-	})
+		resetPrefsForTesting();
+	});
 
 	afterEach(() => {
-		resetPrefsForTesting()
-	})
+		resetPrefsForTesting();
+	});
 
-	it('returns null when no prefs are stored', () => {
-		expect(readPrefs()).toBeNull()
-	})
+	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("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 malformed JSON", () => {
+		globalThis.localStorage.setItem(OVERLAY_PREFS_STORAGE_KEY, "{not json");
+		expect(readPrefs()).toBeNull();
+	});
 
-	it('returns null when the stored payload is missing fields', () => {
+	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()
-	})
-})
+		);
+		expect(readPrefs()).toBeNull();
+	});
+});
 
-describe('writePrefsDebounced timing', () => {
+describe("writePrefsDebounced timing", () => {
 	beforeEach(() => {
-		vi.useFakeTimers()
-		resetPrefsForTesting()
-	})
+		vi.useFakeTimers();
+		resetPrefsForTesting();
+	});
 
 	afterEach(() => {
-		vi.useRealTimers()
-		resetPrefsForTesting()
-	})
+		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("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)
-	})
-})
+	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/panel-state.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	OVERLAY_DEFAULT_WIDTH_PX,
+	OVERLAY_MIN_WIDTH_PX,
+	OVERLAY_OUTSIDE_TOGGLE_SUPPRESS_MS,
+} from "../app/runtime/constants";
+import {
+	flushPrefsForTesting,
+	readPrefs,
+	resetPrefsForTesting,
+} from "../app/runtime/overlay-prefs";
+import { clampWidth, createChatPanelState } from "../app/runtime/panel-state";
+
+afterEach(() => {
+	resetPrefsForTesting();
+});
+
+describe("chat panel state", () => {
+	it("starts closed at the default width, then remembers what the user chose", () => {
+		const panel = createChatPanelState();
+		expect(panel.isOpen.value).toBe(false);
+		expect(panel.width.value).toBe(OVERLAY_DEFAULT_WIDTH_PX);
+		panel.toggle();
+		panel.resize(520);
+		panel.commitWidth();
+		flushPrefsForTesting();
+		expect(readPrefs()).toEqual({ width: 520, isOpen: true });
+		const reloaded = createChatPanelState();
+		expect(reloaded.isOpen.value).toBe(true);
+		expect(reloaded.width.value).toBe(520);
+	});
+
+	it("keeps the width between the minimum and most of the viewport", () => {
+		expect(clampWidth(10)).toBe(OVERLAY_MIN_WIDTH_PX);
+		expect(clampWidth(100_000)).toBeLessThan(globalThis.innerWidth);
+	});
+
+	it("does not let the launcher reopen the panel an outside click just closed", () => {
+		const panel = createChatPanelState();
+		panel.toggle();
+		panel.closeFromOutside(performance.now());
+		panel.toggleFromLauncher();
+		expect(panel.isOpen.value).toBe(false);
+	});
+
+	it("lets the launcher open the panel again a moment later, and the shortcut at once", () => {
+		const panel = createChatPanelState();
+		panel.toggle();
+		panel.closeFromOutside(performance.now());
+		panel.toggle();
+		expect(panel.isOpen.value).toBe(true);
+		panel.closeFromOutside(
+			performance.now() - OVERLAY_OUTSIDE_TOGGLE_SUPPRESS_MS - 1,
+		);
+		panel.toggleFromLauncher();
+		expect(panel.isOpen.value).toBe(true);
+	});
+});

package/frontend-vue/tests/session-gate.test.ts

@@ -1,39 +1,39 @@
-import { nextTick, ref } from 'vue'
-import { describe, expect, it, vi } from 'vitest'
-import { runWhenLoggedIn } from '../app/runtime/session-gate'
+import { nextTick, ref } from "vue";
+import { describe, expect, it, vi } from "vitest";
+import { runWhenLoggedIn } from "../app/runtime/session-gate";
 
-describe('session gate', () => {
-	it('starts immediately when the session is already hydrated', () => {
-		const start = vi.fn()
-		runWhenLoggedIn(() => true, start)
-		expect(start).toHaveBeenCalledTimes(1)
-	})
+describe("session gate", () => {
+	it("starts immediately when the session is already hydrated", () => {
+		const start = vi.fn();
+		runWhenLoggedIn(() => true, start);
+		expect(start).toHaveBeenCalledTimes(1);
+	});
 
-	it('starts once the session appears, and only once', async () => {
-		const loggedIn = ref(false)
-		const start = vi.fn()
-		runWhenLoggedIn(() => loggedIn.value, start)
-		expect(start).not.toHaveBeenCalled()
+	it("starts once the session appears, and only once", async () => {
+		const loggedIn = ref(false);
+		const start = vi.fn();
+		runWhenLoggedIn(() => loggedIn.value, start);
+		expect(start).not.toHaveBeenCalled();
 
-		loggedIn.value = true
-		await nextTick()
-		expect(start).toHaveBeenCalledTimes(1)
+		loggedIn.value = true;
+		await nextTick();
+		expect(start).toHaveBeenCalledTimes(1);
 
-		loggedIn.value = false
-		await nextTick()
-		loggedIn.value = true
-		await nextTick()
-		expect(start).toHaveBeenCalledTimes(1)
-	})
+		loggedIn.value = false;
+		await nextTick();
+		loggedIn.value = true;
+		await nextTick();
+		expect(start).toHaveBeenCalledTimes(1);
+	});
 
-	it('never starts once the gate is stopped', async () => {
-		const loggedIn = ref(false)
-		const start = vi.fn()
-		const stop = runWhenLoggedIn(() => loggedIn.value, start)
+	it("never starts once the gate is stopped", async () => {
+		const loggedIn = ref(false);
+		const start = vi.fn();
+		const stop = runWhenLoggedIn(() => loggedIn.value, start);
 
-		stop()
-		loggedIn.value = true
-		await nextTick()
-		expect(start).not.toHaveBeenCalled()
-	})
-})
+		stop();
+		loggedIn.value = true;
+		await nextTick();
+		expect(start).not.toHaveBeenCalled();
+	});
+});